redux-devtools-extension#composeWithDevTools JavaScript Examples

store = () => {
  let store = createStore(
    persistedReducer,
    composeWithDevTools(
      applyMiddleware(
        axiosMiddleware(axiosClient),
        thunkMiddleware,
        loggerMiddleware
      ),
    ),
  );
  let persistor = persistStore(store);

  return { store, persistor }
}

customMiddleware = composeWithDevTools(
  applyMiddleware(
    getSelectedCourseMiddleware,
    checkClashOrDeleteMiddleWare,
    checkSectionSwapMiddleware,
    checkLunchHourMiddleware,
    addSectionMiddleware,
    deleteSectionMiddleware,
    saveTTMiddleware,
    closeDialogMiddleware,
    thunk
  )
)

createOwnStore = (reducers) => {
  const middlewares = [thunkMiddleware, logger];
  const middlewareEnchancer = applyMiddleware(...middlewares);

  const enchancers = [middlewareEnchancer];
  const composedEnchancers = composeWithDevTools(...enchancers);

  return createStore(reducers, undefined, composedEnchancers);
}

store = createStore(
  persistedReducer,
  undefined,
  composeWithDevTools(
    applyMiddleware(
      sagaMiddleware
    )
  )
)

export default function configureStore() {
  const store = createStore(
    rootReducer,
    initialState,
    composeWithDevTools(applyMiddleware(thunkMiddleware))
  );

  if (module.hot) {
    // Enable Webpack hot module replacement for reducers
    module.hot.accept('../reducers/root', () => {
      const nextRootReducer = require('../reducers/root').default;
      store.replaceReducer(nextRootReducer);
    });
  }

  return store;
}

store = createStore(
  rootReducer,
  // If you use logger , the logger should be the last.
  composeWithDevTools(
    applyMiddleware(
      ReduxThunk.withExtraArgument({ history: history }),
      logger
    )
  )
)

configureStore = () => {
  const store = createStore(
    rootReducer,
    composeWithDevTools(
      applyMiddleware(
        sagaMiddleware,
      ),
    ),
  );

  sagaMiddleware.run(rootSaga);

  return store;
}

export function configureStore(initialState = {}) {
  // Middleware and store enhancers
  const enhancers = [applyMiddleware(thunk)];

  let store;
  if (process.env.NODE_ENV === 'development') {
    store = createStore(reducer, initialState, composeWithDevTools(...enhancers));
  } else {
    store = createStore(reducer, initialState, compose(...enhancers));
  }

  return store;
}

configureStore = (initialState) => {
  const store = createStore(
    rootReducer,
    initialState,
    composeWithDevTools(
      applyMiddleware(reduxThunk.withExtraArgument({ mernApi }))
    )
  );

  if (module.hot) {
    // Enable hot module replacement for reducers
    module.hot.accept('./reducers', () => {
      const nextRootReducer = require('./reducers').default;
      store.replaceReducer(nextRootReducer);
    });
  }

  return store;
}

store = createStore(
   rootReducer,
   initialState,
   composeWithDevTools(applyMiddleware(reduxThunk))
)

store = createStore(
  rootReducer,
  initialState,
  composeWithDevTools(applyMiddleware(...middleWare))
)

middleware = composeWithDevTools(
  applyMiddleware(thunkMiddleware, createLogger({collapsed: true}))
)

store = createStore(
  rootReducer,
  composeWithDevTools(applyMiddleware(ReduxThunk)),
)

middleware = composeWithDevTools(
  applyMiddleware(thunkMiddleware, createLogger({ collapsed: true }))
)

store = createStore(
  rootReducer,
  initialState,
  composeWithDevTools(applyMiddleware(...middleware))
)

store = createStore(
  reducer,
  composeWithDevTools(
    applyMiddleware(sagaMiddleware),
    Reactotron.createEnhancer(),
  ),
)

devTools =
  process.env.NODE_ENV === 'production'
    ? applyMiddleware(thunk)
    : composeWithDevTools(applyMiddleware(thunk))

store = createStore( reducers, composeWithDevTools(
  applyMiddleware( ...middleware ),
  // other store enhancers if any
) )

export function createStore(initialState: $Shape<State>): FlatrisReduxStore {
  return createReduxStore(
    rootReducer,
    initialState,
    composeWithDevTools(applyMiddleware(thunk))
  );
}

store = createStore(
  rootReducer,
  composeWithDevTools(applyMiddleware(thunk)),
)

export default function configureStore(reducer, initialState = {}) {
    const storeEnhancers = composeWithDevTools(applyMiddleware(thunk));

    return createStore(reducer, initialState, storeEnhancers);
}

store = createStore(reducer, composeWithDevTools(applyMiddleware(thunk)))

composedEnhancers = composeWithDevTools(
    applyMiddleware(...middleware),
    ...enhancers
)

store = createStore(
  reducers,
  composeWithDevTools(applyMiddleware(...middleware))
)

store = createStore(rootReducer, composeWithDevTools(applyMiddleware()))

store = createStore(
  rootReducer,
  composeWithDevTools(applyMiddleware(thunk))
)

configureStore = (preloadedState) => {
  const store = createStore(
    rootReducer,
    composeWithDevTools(applyMiddleware())
  );

  return store;
}

store = createStore(rootReducer, composeWithDevTools())

store = createStore(
  rootReducer,
  initialState,
  composeWithDevTools(applyMiddleware(...middleware))
)