How to use the redux-logger.default function in redux-logger

// @flow
import type { Middleware } from 'constants/types/Redux'
import epicMiddleware from './epicMiddleware'

const middlewares: Array = [
  epicMiddleware,
]

if (process.env.NODE_ENV !== 'production') {
  middlewares.push(require('redux-logger').default())
}

export default middlewares

import App from '../components/App';
import { BrowserRouter } from 'react-router-dom';
import { Provider } from "react-redux";
import { createStore, applyMiddleware, compose as compose0 } from 'redux';
import createSagaMiddleware from 'redux-saga';
import reducer from '../reducer';
import saga from './saga';
import { fromJS } from 'immutable';

const sagaMiddleware = createSagaMiddleware();
const middlewares = [sagaMiddleware];
const compose = window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__ || compose0;

if(__DEV__){
  const logger = require('redux-logger').default;
  middlewares.push(logger);
};

const enhancers = applyMiddleware(...middlewares);
const initState = createStore(reducer,
  fromJS(window._colorpk),
  compose(enhancers),
);

sagaMiddleware.run(saga);

const render = () => {
  hydrate(

export default function createState({
  initState,
  hoodMap,
  rootReducer,
  rootSaga,
}: Props): { store: Store; persistor: Persistor } {
  const sagaMiddleware = createSagaMiddleware({
    onError: log,
  });
  const middleware: Middleware[] = [sagaMiddleware];
  const persistedReducer = persistReducer(persistConfig, rootReducer);

  if (process.env.NODE_ENV === 'development') {
    const logger = require('redux-logger').default;
    middleware.push(logger);
  }

  const store = createStore(
    persistedReducer,
    initState,
    applyMiddleware(...middleware),
  );
  sagaMiddleware.run(rootSaga, hoodMap);

  const persistor = persistStore(store);
  return { store, persistor };
}

export default function createState({
  initState,
  rootReducer,
  rootSaga,
}: Props): { store: Store; persistor: Persistor } {
  const sagaMiddleware = createSagaMiddleware({
    onError: log,
  });
  const middleware: Middleware[] = [sagaMiddleware];
  const persistedReducer = persistReducer(persistConfig, rootReducer);

  if (process.env.NODE_ENV === 'development') {
    const logger = require('redux-logger').default;
    middleware.push(logger);
  }

  const store = createStore(
    persistedReducer,
    initState,
    applyMiddleware(...middleware),
  );
  sagaMiddleware.run(rootSaga);

  const persistor = persistStore(store);
  return { store, persistor };
}

applyMiddleware,
  compose as compose0,
  combineReducers,
} from 'redux';

import { createEpicMiddleware } from 'redux-observable';
import rootEpic from './epic';
import moduleReducers from './reducer';

const epicMiddleware = createEpicMiddleware();
const middlewares = [epicMiddleware];
let compose = compose0;

if (process.env.NODE_ENV === 'development') {
  const logger = require('redux-logger').default;
  middlewares.push(logger);
  compose = window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__ || compose0;
}

const enhancers = applyMiddleware(...middlewares);
const store = createStore(
  combineReducers(moduleReducers),
  {},
  compose(enhancers)
);

epicMiddleware.run(rootEpic);

export default store;

import { createStore, applyMiddleware } from 'redux';
import rootReducer from '../reducers/root_reducer';
import thunk from 'redux-thunk';

const middlewares = [thunk];

if (process.env.NODE_ENV !== 'production') {
  const logger = require('redux-logger').default;
  middlewares.push(logger);
}

const configureStore = (preloadedState = {}) => (
  createStore(
    rootReducer,
    preloadedState,
    applyMiddleware(...middlewares)
  )
);

export default configureStore;