export default function configureStore ({ initialState = {}, history, socket }) {
// Sync with router via history instance (main.js)
const routerHistory = syncHistory(history);
let routerMiddleware = applyMiddleware(thunk, routerHistory);
// socket io middleware
const socketMiddleware = applyMiddleware(socketIoMiddleware(socket));
// Compose final middleware and use devtools in debug environment
let middleware = compose(routerMiddleware, socketMiddleware);
if (__DEBUG__) {
const devTools = window.devToolsExtension
? window.devToolsExtension()
: require('components/containers/DevTools').default.instrument();
middleware = compose(routerMiddleware, socketMiddleware, devTools);
}
// Create final store and subscribe router in debug env ie. for devtools
const store = middleware(createStore)(rootReducer, initialState);
if (__DEBUG__) routerHistory.listenForReplays(store, ({ router }) => router.location);
if (module.hot) {
module.hot.accept('../reducers/rootReducer', () => {
const nextRootReducer = require('../reducers/rootReducer').default;
store.replaceReducer(nextRootReducer);
});
}
return store;
}
/**
* Method to create stores based on a set of passed
* reducers
* @param initialState
* @returns {*}
*/
export default function configureStore(initialState) {
const socket = io('http://localhost:8000');
const socketIoMiddleware = createSocketIoMiddleware(socket, '/server');
const reduxRouterMiddleware = syncHistory(hashHistory);
const middleware = applyMiddleware(thunk, reduxRouterMiddleware, socketIoMiddleware);
const createStoreWithMiddleware = compose(
middleware,
// Required! Enable Redux DevTools with the monitors you chose
DevTools.instrument(),
// Optional. Lets you write ?debug_session=<key> in address bar to persist debug sessions
persistState(getDebugSessionKey())
);
const store = createStoreWithMiddleware(createStore)(rootReducer, initialState);
reduxRouterMiddleware.listenForReplays(store);
if (module.hot) {
module.hot.accept('../reducers', () => {
const nextRootReducer = require('../reducers').default;
store.replaceReducer(nextRootReducer);
});
}
return store;
}
export default function configureStore(initialState) {
const reduxRouterMiddleware = syncHistory(history);
const middleware = [
thunk, promiseMiddleware, reduxRouterMiddleware,
];
const store = createStore(
rootReducer,
initialState,
compose(
applyMiddleware(...middleware),
DevTools.instrument(),
window.devToolsExtension ? window.devToolsExtension() : f => f
)
);
if (module.hot) {
reduxRouterMiddleware.listenForReplays(store);
// Enable Webpack hot module replacement for reducers
module.hot.accept('../reducers', () => {
const nextRootReducer = require('../reducers');
store.replaceReducer(nextRootReducer);
});
}
return store;
}
export default function configureStore ({ initialState = {}, history }) {
// Sync with router via history instance (main.js)
const routerMiddleware = syncHistory(history)
// Compose final middleware and use devtools in debug environment
let middleware = applyMiddleware(thunk, routerMiddleware, checkLoginMiddleware)
if (__DEBUG__) {
const devTools = window.devToolsExtension
? window.devToolsExtension()
: require('containers/DevTools').default.instrument()
middleware = compose(middleware, devTools)
}
// Create final store and subscribe router in debug env ie. for devtools
const store = middleware(createStore)(rootReducer, initialState)
if (__DEBUG__) routerMiddleware.listenForReplays(store, ({ router }) => router.location)
if (module.hot) {
module.hot.accept('./rootReducer', () => {
const nextRootReducer = require('./rootReducer').default
store.replaceReducer(nextRootReducer)
})
}
return store
}
export default (props) => {
const initialState = omit(props, 'location')
const reduxRouterMiddleware = syncHistory(browserHistory)
const store = createStore(initialState, reduxRouterMiddleware)
if (process.env.NODE_ENV === 'development') {
// Required for replaying actions from devtools to work
reduxRouterMiddleware.listenForReplays(store)
const DevTools = require('containers/DevTools').default
return (
<Provider store={store}>
<div>
<Router history={browserHistory}>
{routes}
</Router>
<DevTools />
</div>
</Provider>
)
} else {
return (
<Provider store={store}>
<Router history={browserHistory}>
{routes}
</Router>
</Provider>
)
}
}
export default function configureStore (initialState = Immutable.Map({})) {
// sync react-router and redux
const reduxRouterMiddleware = syncHistory(browserHistory)
// apply different middleware in dev and production
const middleware = process.env.NODE_ENV === 'production'
? [ thunk, reduxRouterMiddleware ]
: [ thunk, reduxRouterMiddleware, logger({ duration: true, stateTransformer: (state) => state.toJS() }) ]
const store = createStore(rootReducer, initialState, compose(
applyMiddleware(...middleware),
// support for reduxDevTools chrome plugin => using redux-developer-tools is an option without chrome plugin
window.devToolsExtension ? window.devToolsExtension() : f => f
))
if (module.hot) {
// Enable Webpack hot module replacement for reducers
module.hot.accept('../reducers', () => {
const nextReducer = require('../reducers')
store.replaceReducer(nextReducer)
})
}
return store
}
export default function configureStore(initialState) {
return createStore(
rootReducer,
initialState,
applyMiddleware(thunk, api, syncHistory(browserHistory))
);
}
export default function configureStore(initialState = {}, history) {
const logger = createLogger({
level: 'info',
duration: true
});
const reduxRouterMiddleware = syncHistory(history);
//persistStateはdevToolsより上に記述
const createStoreWithMiddleware = compose(
applyMiddleware(...Middlewares, thunk, promise, logger, reduxRouterMiddleware),
persistState(['application']),
//window.devToolsExtension ? window.devToolsExtension() : DevTools.instrument()
)(createStore);
const store = createStoreWithMiddleware(rootReducer, initialState);
// Required for replaying actions from devtools to work
reduxRouterMiddleware.listenForReplays(store)
if (module.hot) {
module.hot.accept('../reducers', () => {
const nextReducer = require('../reducers');
store.replaceReducer(nextReducer);
});
}
return store;
}
export default function createStore(history, client, data) {
// Sync dispatched route actions to the history
const reduxRouterMiddleware = syncHistory(history);
const middleware = [createMiddleware(client), reduxRouterMiddleware];
let finalCreateStore;
if (__DEVELOPMENT__ && __CLIENT__ && __DEVTOOLS__) {
finalCreateStore = compose(
applyMiddleware(...middleware),
window.devToolsExtension ? window.devToolsExtension() : argument => argument
)(_createStore);
} else {
finalCreateStore = applyMiddleware(...middleware)(_createStore);
}
const reducer = require('./modules/reducer');
const store = finalCreateStore(reducer, data);
reduxRouterMiddleware.listenForReplays(store);
if (__DEVELOPMENT__ && module.hot) {
module.hot.accept('./modules/reducer', () => {
store.replaceReducer(require('./modules/reducer'));
});
}
return store;
}
export default function configureStore (history, initialState) {
const reduxRouterMiddleware = syncHistory(history);
const middlewares = [thunk, reduxRouterMiddleware];
let middleware = applyMiddleware(...middlewares);
if (__DEVELOPMENT__) {
const logger = require('redux-logger')();
const devTools = require('../containers/DevTools').default.instrument()
middleware = compose(applyMiddleware(...middlewares, logger), devTools)
}
const store = middleware(createStore)(reducer, initialState);
// required for replaying actions from devtools to work
if (__DEVTOOLS__) {
reduxRouterMiddleware.listenForReplays(store, ({ routing }) => routing.location);
}
if (module.hot) {
module.hot.accept('../reducers', () => {
const nextRootReducer = require('../reducers').default
store.replaceReducer(nextRootReducer)
})
}
return store
}
waldoService.getMaps((err, mapResponse) => {
if (err) throw err;
const initialState = {
maps: mapResponse,
currentMap: 0
};
const history = createMemoryHistory(req.path);
const simpleRouter = syncHistory(history);
const finalCreateStore = applyMiddleware(thunk, simpleRouter)(createStore);
const store = finalCreateStore(reducers, initialState);
simpleRouter.listenForReplays(store);
match({ routes, location: req.url }, (error, redirectLocation, renderProps) => {
if (error) {
res.status(500).send(error.message);
} else if (redirectLocation) {
res.redirect(302, redirectLocation.pathname + redirectLocation.search);
} else if (renderProps) {
res.render('index', { initialState: JSON.stringify(store.getState()) });
} else {
res.status(404).render('error');
}
});
});
export default function createStore(history, client, data) {
const reduxRouterMiddleware = syncHistory(history);
const middleware = [reduxRouterMiddleware, thunk];
let finalCreateStore;
if (__DEVELOPMENT__ && __CLIENT__ && __DEVTOOLS__) {
const { persistState } = require('redux-devtools');
const DevTools = require('../containers/DevTools/DevTools');
finalCreateStore = compose(
applyMiddleware(...middleware),
window.devToolsExtension ? window.devToolsExtension() : DevTools.instrument(),
persistState(window.location.href.match(/[?&]debug_session=([^&]+)\b/))
)(_createStore);
} else {
finalCreateStore = applyMiddleware(...middleware)(_createStore);
}
const reducer = require('./modules/reducer');
const store = finalCreateStore(reducer, data);
reduxRouterMiddleware.listenForReplays(store);
if (__DEVELOPMENT__ && module.hot) {
module.hot.accept('./modules/reducer', () => {
store.replaceReducer(require('./modules/reducer'));
});
}
return store;
}
export default function configureStore (initialState) {
const middlewares = [thunk, dataloader, promise]
if (__CLIENT__) {
middlewares.push(syncHistory(browserHistory))
} else {
middlewares.push(syncHistory(createMemoryHistory()))
}
if (__DEV__) {
middlewares.push(createLogger())
}
const finalCreateStore = applyMiddleware(...middlewares)(createStore)
const store = finalCreateStore(rootReducer, initialState)
return store
}
export default function create(providedMiddleware, data, req) {
// TODO: parameterize react-router
let router;
if (__CLIENT__) {
router = syncHistory(useScroll(() => browserHistory)());
} else {
router = syncHistory(createMemoryHistory());
}
const defaultMiddleware = [ router ];
// backward compatibility to 2.x api expecting object for middleware instead of array:
const customMiddleware = !providedMiddleware.concat ? map(providedMiddleware, (m) => { return m; }) : providedMiddleware;
let middleware = customMiddleware.concat(defaultMiddleware);
// if (__CLIENT__ && __LOGGER__) {
// middleware.push(createLogger({ collapsed: true }));
// }
// Add express request as a 2nd argument to the middlewares
if (__SERVER__) {
middleware = middleware.map((fn) => function (obj) {
return fn.call(this, obj, req);
});
}
const devtoolsExtensionMiddleware = () =>
__CLIENT__ &&
typeof window === 'object' &&
typeof window.devToolsExtension === 'function'
? window.devToolsExtension() : f => f
// const useDevtools = __DEVELOPMENT__ && __CLIENT__ && __DEVTOOLS__;
const finalCreateStore = compose(
applyMiddleware(...middleware),
devtoolsExtensionMiddleware()
)(createStore)
const store = finalCreateStore(reducers, data);
hmr(store);
return store;
}
export function registerRedux(userOpts) {
const defaultMiddlware = [];
const defaultEnhancers = [];
const opts = {...defaultOpts, ...userOpts};
if (opts.debug) {
var {DevTools} = require('./devtools');
defaultEnhancers.push(DevTools.instrument());
}
const reduxRouterMiddleware = syncHistory(browserHistory)
defaultMiddlware.push(reduxRouterMiddleware);
if (!opts.debug || !opts.disableLogger) {
defaultMiddlware.push(genericlogger);
}
const middleware = applyMiddleware(
...defaultMiddlware,
...opts.middleware
);
const reducer = combineReducers({
routing: routeReducer,
...opts.reducers
})
const store = compose(
middleware,
...defaultEnhancers
)(createStore)(reducer);
// Required for replaying actions from devtools to work
reduxRouterMiddleware.listenForReplays(store);
if (!opts.routes) {
throw new Error("Missing `router` key with a component as it's value");
}
const Root = () => (
<Provider store={store}>
<div>
<opts.routes history={browserHistory} />
{DevTools &&
<DevTools />
}
</div>
</Provider>
)
if (opts.renderToElementId) {
ReactDOM.render(<Root />, document.getElementById(opts.renderToElementId));
}
return {store, dispatch: store.dispatch, Root};
}
const configureStore = (history, initialState) => {
const routerMiddleware = syncHistory(history)
const createStoreWithMiddleware = compose(
applyMiddleware(routerMiddleware)
)(createStore)
return createStoreWithMiddleware(rootReducer, initialState)
}
export default function configureStore (initialState, history) {
const reduxRouterMiddleware = syncHistory(history)
const createStoreWithMiddleware = compose(
applyMiddleware(thunk, Middleware, reduxRouterMiddleware)
)(createStore)
const store = createStoreWithMiddleware(rootReducer, initialState)
return store
}
export default function configureStore(initialState) {
const reduxRouterMiddleware = syncHistory(history);
const store = createStore(
reducer,
initialState,
applyMiddleware(thunk, reduxRouterMiddleware)
);
return store;
}
export default function configureStore(initialState, history) {
const historyMiddleware = syncHistory(history)
const store = compose(
applyMiddleware(historyMiddleware, thunk, promise)
)(createStore)(rootReducer, initialState)
historyMiddleware.listenForReplays(store)
return store
}
export default function configureStore({ initialState = {}, history }) {
const store = createStore(
reducer,
initialState,
applyMiddleware(
createSagaMiddleware(rootSaga),
syncHistory(history)
)
)
return store
}
export default function configureStore(initialState) {
// Sync dispatched route actions to the history
const reduxRouterMiddleware = syncHistory(browserHistory);
const finalCreateStore = compose(
applyMiddleware(thunk, reduxRouterMiddleware)
)(createStore);
const store = finalCreateStore(rootReducer, initialState);
return store;
}
function configureStore(initialState = {}) {
const reduxRouterMiddleware = syncHistory(browserHistory);
const store = createStore(
combineReducers({
routing: routeReducer
}),
initialState,
compose(
applyMiddleware(reduxRouterMiddleware)
)
);
return store;
}
export default (history) => {
const
reduxRouterMiddleware = syncHistory(history),
middlewares = process.env.NODE_ENV === 'development'
? [reduxRouterMiddleware, createLogger()]
: [reduxRouterMiddleware],
reducers = combineReducers({
routing: routeReducer,
questions
}),
store = compose(applyMiddleware(...middlewares))(createStore)(reducers);
reduxRouterMiddleware.listenForReplays(store);
return store;
};
export default (initialState) => {
const store = applyMiddleware(
syncHistory(browserHistory),
thunk
)(createStore)(reducer, initialState);
if (module.hot) {
module.hot.accept('./reducer', () => {
store.replaceReducer(require('./reducer').default);
});
}
return store;
};
export default function configure(initialState) {
const enhancer = compose(
applyMiddleware(syncHistory(hashHistory), createSagaMiddleware(sagas)),
window.devToolsExtension ? window.devToolsExtension() : f => f
);
const store = createStore(rootReducer, initialState, enhancer);
if (module.hot) {
module.hot.accept('../reducers', () => {
const nextReducer = require('../reducers');
store.replaceReducer(nextReducer);
});
}
return store;
}
export default function configureStore(initialState, history) {
const historyMiddleware = syncHistory(history)
const store = compose(
applyMiddleware(historyMiddleware, thunk, logger, promise),
DevTools.instrument(),
persistState(getDebugSessionKey())
)(createStore)(rootReducer, initialState)
historyMiddleware.listenForReplays(store)
if (module.hot) {
module.hot.accept('../reducers', () =>
store.replaceReducer(require('../reducers').default)
)
}
return store
}
export function createStore(reducers, history) {
const createStoreWithMiddleware = compose(
applyMiddleware(
thunk,
syncHistory(history),
),
window.devToolsExtension ? window.devToolsExtension() : f => f
)(reduxCreateStore);
const reducer = combineReducers({
...reducers,
routing: routeReducer
});
const store = createStoreWithMiddleware(reducer);
return store;
}
export default function configureStore (initialState, history) {
const groutMiddleware = createMiddleware('tessellate', devSettings)
const reduxRouterMiddleware = syncHistory(history)
const createStoreWithMiddleware = compose(
applyMiddleware(thunk, groutMiddleware, reduxRouterMiddleware),
typeof window === 'object' && typeof window.devToolsExtension !== 'undefined' ? window.devToolsExtension() : f => f
)(createStore)
const store = createStoreWithMiddleware(rootReducer, initialState)
if (module.hot) {
// Enable Webpack hot module replacement for reducers
module.hot.accept('../reducers', () => {
const nextRootReducer = require('../reducers')
store.replaceReducer(nextRootReducer)
})
}
return store
}
const configureStore = (initialState) => {
const reduxRouterMiddleware = syncHistory(browserHistory);
const createDevStore = compose(applyMiddleware(reduxRouterMiddleware), typeof window === 'object' && typeof window.devToolsExtension !== 'undefined' ? window.devToolsExtension() : (f) => f)(createStore);
const createProdStore = applyMiddleware(reduxRouterMiddleware)(createStore);
let store;
if(process.env.NODE_ENV == 'development') {
store = createDevStore(reducer, initialState);
if(module.hot) {
module.hot.accept('./reducers', () => {
store.replaceReducer(require('./reducers/index').default);
});
}
} else {
store = createProdStore(reducer, initialState);
}
reduxRouterMiddleware.listenForReplays(store);
return store;
};
export default (initialState) => {
const create = __DEV__ && window.devToolsExtension ? window.devToolsExtension()(createStore) : createStore;
const createStoreWithMiddleware = applyMiddleware(
thunkMiddleware,
promiseMiddleware,
syncHistory(hashHistory)
)(create);
const store = createStoreWithMiddleware(rootReducer, initialState);
if (__DEV__) {
module.hot && module.hot.accept('../reducers', () => {
const nextReducer = require('../reducers');
store.replaceReducer(nextReducer)
});
}
return store;
}