redux#combineReducers JavaScript Examples

rootReducer = combineReducers({
    navigation,
    auth,
    cards,
    games,
    news,
    toastr: toastrReducer,
    api,
    admin,
    user,
    account,
    lobby,
    stats
})

mainReducer = combineReducers({
    projectList: projectListReducer,
    notifications: notificationReducer,
    parameters: parametersReducer,
    updateParameters: updateParametersReducer,
    uiFlags: uiFlagsReducer,
    profile: profileReducer,
    bom: bomReducer
})

//mock redux

function renderWithRedux(
    ui,
    {
        store = createStore(
            combineReducers({
                user: reducer
            }),
            applyMiddleware(thunk, logger)
        )
    } = {}
) {
    
    return {
        ...render(<Provider store={store}>{<Router>{ui}</Router>}</Provider>),
        store
    };
}

rootReducer = combineReducers({
	form: formReducer,
	user: userReducer,
	store: storeReducer,
	cart: cartReducer,
	search: searchReducer,
	savedCart: savedCartReducer,
	dashboard: dashboardReducer,
	order: orderReducer,
	product: productReducer,
	orders: getOrdersReducer,
	onboard: onboardReducer,
	logo: logoReducer,
	color: colorReducer
})

reducer = combineReducers({
	home: homeReducer,
	login: loginReducer,
	adapter: adapterReducer,
	header: headerReducer,
	projectList: projectListReducer,
	newProject: newProjectReducer,
	customAlert: customAlertReducer,
	project: projectReducer,
})

reducers = combineReducers({
  nav: require('./NavigationRedux').reducer,
  products: require('./ProductsRedux').reducer,
  category: require('./CategoryRedux').reducer,
  auth: require('./AuthRedux').reducer,
  session: require('./SessionRedux').reducer,
  invoice: require('./InvoiceRedux').reducer,
  order: require('./OrderRedux').reducer,
  confirm: require('./ConfirmPaymentRedux').reducer,
})

export function makeRootReducer(asyncReducers) {
  return combineReducers({
    // Add sync reducers here
    firebase,
    firestore,
    notifications,
    location: locationReducer,
    ...asyncReducers
  })
}

rootReducer = combineReducers({
  user,
  signup,
  login,
  search,
  searchForm,
  wishlists,
  trips,
  message,
  home,
  modal,
  map,
  reservation,
  socket,
  mouseEvents,
})

rootReducer = combineReducers({
  users,
  alerts,
  apis,
  metas,
  operations,
  resources,
  applications
})

rootReducer = combineReducers({
    actionType: actionTypeReducer,
    plannerList: fetchPlannerReducer,
    appLoginPayload: appLoginReducer,
    addPlannerPayload: addPlannerReducer,
    firebasePlannerList: fetchFirebasePlannerReducer,
    googlePlannerList: fetchGoogleCalendarReducer,
    microsoftPlannerList: fetchMicrosoftPlannerReducer,
    fetchStudentsListPayload: fetchStudentsListReducer,
    loadFBAnnoucements: fetchFBAnnouncementReducer,
    fetchAnnouncementPayload: fetchAnnouncementReducer,
    grantDrivePermissionState: grantGoogleDrivePermissionReducer,
    uploadDriveAttachment: uploadFilesGoogleDriveReducer,
    plannerCallback: createPlannerReducer,
    createFirebasePlannerPayload: createFirebasePlannerReducer,
    createGooglePlannerPayload: createGooglePlannerReducer,
    createMicrosoftPlannerPayload: createMicrosoftPlannerReducer,
})

constructor(history, initialState = {}) {
    const reducer = combineReducers({
      ...reducers,
      apollo: ApolloClientSingleton.reducer(),
      routing: routerReducer
    });

    this.data = createStore(
      reducer,
      initialState,
      compose(
        applyMiddleware(
          routerMiddleware(history),
          ApolloClientSingleton.middleware(),
          ReduxThunk.withExtraArgument(ApolloClientSingleton)
        ),
        typeof window === "object" &&
          typeof window.devToolsExtension !== "undefined"
          ? window.devToolsExtension()
          : f => f
      )
    );
  }

rootReducer = combineReducers({
  Auth,
  ConnectWallet,
  HeaderOptions,
  Modal,
  Filter,
  Collections,
  Tokens,
  Price,
})

export default function configureStore(history, initialState) {
  const reducers = {
    form: formReducer,
    router: connectRouter(history),
    auth,
    home,
    provider,
    store
  };

  const middleware = [thunk, routerMiddleware(history)];

  const enhancers = [];
  // eslint-disable-next-line no-undef
  const isDevelopment = process.env.NODE_ENV === "development";

  if (
    isDevelopment &&
    typeof window !== "undefined" &&
    window.devToolsExtension
  ) {
    enhancers.push(window.devToolsExtension());
  }

  const rootReducer = combineReducers(reducers);

  return createStore(
    rootReducer,
    initialState,
    compose(
      applyMiddleware(...middleware),
      ...enhancers
    )
  );
}

makeStore = () => {
  const isServer = typeof window === 'undefined';

  if (isServer) {
    return createOwnStore(rootReducer);
  }

  const rootReducers = combineReducers({
    notification: notificationReducer
  });
  return createOwnStore(rootReducers);

}

rootReducer = combineReducers({
  
  // INSERT HERE YOUR CUSTOM REDUCERS
  LoginReducer,
  ProfileReducer,
  UserEditReducer,
  UserListReducer,

  // START COMBINE REDUCERS
	HomeReducer,
	CourseEditReducer,
	CourseListReducer,
	ExamEditReducer,
	ExamListReducer,
	StudentEditReducer,
	StudentListReducer,
	TeacherEditReducer,
	TeacherListReducer,
 // END COMBINE REDUCERS

})

/**
 * Merges the main reducer with the router state and dynamically injected reducers
 */
export default function createReducer(injectedReducers = {}) {
  const rootReducer = combineReducers({
    global: globalReducer,
    language: languageProviderReducer,
    router: connectRouter(history),
    ...injectedReducers,
  });

  return rootReducer;
}

// Root reducer
export default function createRootReducer(history: HashHistory) {
  return combineReducers<{}, *>({
    router: connectRouter(history),
    window: windowReducer,
    monaco: monacoReducer,
    preferences: preferencesReducer,
    contextEvaluation: contextEvaluationReducer
  });
}

rootReducer = (history) =>
  combineReducers({
    router: connectRouter(history),
    exchange: ExchangeInfoReducer,
    tabs: TabsReducer,
    tradePanel: TradePanelReducer,
    layoutManager: LayoutManagerReducer,
    liquidityMining: LiquidityMiningReducer,
    currentMarket: CurrentMarketReducer,
    orderBook: OrderBookReducer,
    tradeHistory: TradeHistoryReducer,
    ticker: TickerReducer,
    modalManager: ModalManagerReducer,
    balances: MyAccountPageReducer,
    myOrders: MyOrdersReducer,
    myOrderPage: MyOrderPageReducer,
    metaMask: MetaMaskReducer,
    walletConnect: WalletConnectReducer,
    walletLink: WalletLinkReducer,
    mewConnect: MewConnectReducer,
    authereum: AuthereumReducer,
    dexAccount: DexAccountReducer,
    nonce: NonceReducer,
    gasPrice: GasPriceReducer,
    legalPrice: LegalPriceReducer,
    commissionReward: CommissionRewardReducer,
    userPreferences: UserPreferenceManagerReducer,
    notifyCenter: NotifyCenterReducer,
  })

export default function configureStore(history, initialState) {
  const reducers = {
    form: formReducer,
    router: connectRouter(history),
    auth,
    home,
    provider,
    productType,
    store
  };

  const middleware = [thunk, routerMiddleware(history)];

  const enhancers = [];
  // eslint-disable-next-line no-undef
  const isDevelopment = process.env.NODE_ENV === "development";

  if (
    isDevelopment &&
    typeof window !== "undefined" &&
    window.devToolsExtension
  ) {
    enhancers.push(window.devToolsExtension());
  }

  const rootReducer = combineReducers(reducers);

  return createStore(
    rootReducer,
    initialState,
    compose(
      applyMiddleware(...middleware),
      ...enhancers
    )
  );
}

rootReducer = (history) => combineReducers({
  dailies,
  display,
  calendar,
  folio,
  gameData,
  itemPrice,
  mounts,
  myGame,
  notification,
  proficiencies,
  router: connectRouter(history),
  session,
  crops,
  taxes,
  tradepacks,
  users,
})

reducers = combineReducers({
  activities,
  app,
  daily,
  nativeData,
  navigation,
  restrictions,
  riskTest,
  statistics,
  triage,
  user
})

rootReducer = combineReducers({
  changePage: viewMainPageReducer,
  selectedSku: setCurrentSkuReducer,
  skus: setSkuReducer,
  product: fetchProductReducer,
  expand: expandGalleryReducer,
  relatedProducts: fetchRelatedReducer,
  currentStyles: setStylesReducer,
  outfits: fetchOutfitReducer,
  currentStyle: setCurrentStyleReducer,
  reviews: fetchReviewsReducer,
  reviewMeta: fetchReviewMetaReducer,
  reviewHelpfulLog: fetchReviewHelpfulLogReducer,
  currentGalleryIndex: setGalleryIndexReducer,
  quantity: setQuantityReducer,
  outfitsCarouselIndex: setOutfitsIndexReducer,
  relatedCarouselIndex: setRelatedIndexReducer
})

rootReducer = combineReducers({
    authentication,
    booking,
    rules,
    results,
    weights,
    spell,
    conjunctions,
    synonyms,
    specialtyExam,
})

constructor(...args) {
        super(...args);
        this.state = {};
        this.namespace = util.getRandomString(8);
        this.store = createStore(
          combineReducers(xformBuilderReducer),
          compose(applyMiddleware(thunkMiddleware))
        );
    }

reducer = combineReducers({
  user: userReducer,
  notification: notificationReducer,
  posts: postReducer,
  postComments: postCommentsReducer,
  subs: subReducer,
  userPage: userPageReducer,
  subPage: subPageReducer,
  search: searchReducer,
  darkMode: themeReducer,
})

rootReducer = combineReducers({
  userPlaylists,
  featuredPlaylists,
  categoryPlaylists,
  playlist,
  listUserPlaylists,

  newReleases,
  album,
  artistAlbums,
  artistSingles,

  relatedArtists,
  followedArtists,
  artist,

  topTracks,
  savedTracks,
  artistTopTracks,

  categories,
  player,
  progressBar,
  charts,
  searchResults,
})

appRootReducer = combineReducers({
  entryRouteReducer: entryRouteReducer,
  appReducer: appReducer,
  tabRouteConfig,
  network,
  accountInfo,
  cache: cacheReducer,
  staking,
  currencyConfig
})

pagination = combineReducers({
  starredByUser: paginate({
    mapActionToKey: (action) => action.login,
    types: [
      ActionTypes.STARRED_REQUEST,
      ActionTypes.STARRED_SUCCESS,
      ActionTypes.STARRED_FAILURE,
    ],
  }),
  stargazersByRepo: paginate({
    mapActionToKey: (action) => action.fullName,
    types: [
      ActionTypes.STARGAZERS_REQUEST,
      ActionTypes.STARGAZERS_SUCCESS,
      ActionTypes.STARGAZERS_FAILURE,
    ],
  }),
})

allReducers = combineReducers({
  wallpaper: wallReducer,
  taskbar: taskReducer,
  desktop: deskReducer,
  startmenu: menuReducer,
  sidepane: paneReducer,
  widpane: widReducer,
  apps: appReducer,
  menus: menusReducer,
  globals: globalReducer,
  setting: settReducer,
  files: fileReducer
})