redux#combineReducers TypeScript Examples

// ------------------------------------------------------------------------------
// --- Register the main services

// --- Application state store (redux)
registerService(
  STORE_SERVICE,
  new KliveStore(
    createStore(
      combineReducers(appReducers),
      getInitialAppState(),
      applyMiddleware(forwardToMainMiddleware)
    )
  )
);

/**
 * inject async reducers object into store
 */
export function injectReducer(asyncReducers/*obj*/) {
    store.allReducers = {
        ...store.allReducers,
        ...asyncReducers,
    }
    store.replaceReducer( combineReducers(store.allReducers) )
}

rootReducer = combineReducers({
  notes,
  username,
  online,
  highlighted,
  chatHighlights,
  messageDelay,
  style,
  missionHighlight,
})

rootReducer = combineReducers({
	auth: persistReducer(
		{
			keyPrefix: "com.unidy2002.thuinfo.persist.auth.",
			storage: KeychainStorage,
			key: "auth",
		},
		auth,
	),
	schedule,
	config,
	credentials: persistReducer(
		{
			keyPrefix: "com.unidy2002.thuinfo.persist.credentials.",
			storage: KeychainStorage,
			key: "credentials",
		},
		credentials,
	),
	top5,
	reservation,
})

rootReducer = combineReducers<RootState>({
  appState: appReducer,
  authState: authReducer,
  blogListState: blogListReducer,
  blogState: blogReducer,
  writerBlogsState: writerBlogsReducer,
  writingPadState: writingPadReducer,
  editorBlogState: editorBlogsReducer,
})

appReducer = combineReducers({
  selectedSite,
  sitesList,
  homepage,
  user,
  collection,
  survey,
  surveyList,
  uploads,
})

describe('getRootReducer', () => {
  it('calls combineReducers from redux', () => {
    getRootReducer();
    expect(combineReducers).toHaveBeenCalledWith({
      edges: edgeReducer,
      editor: editorReducer,
      nodes: nodeReducer,
      panels: panelReducer,
      plugins: pluginReducer,
      potentialEdge: potentialEdgeReducer,
      potentialNode: potentialNodeReducer,
      undoHistory: undoHistoryReducer,
      workspace: workspaceReducer,
    });
  });
});

export default function configureStore(history: History, initialState?: AppState): Store {
  const middleware = [
    thunk,
    routerMiddleware(history)
  ];

  const rootReducer = combineReducers({
    ...reducers,
    router: connectRouter(history)
  });

  const enhancers: any[] = [];
  const windowIfDefined = typeof window === 'undefined' ? null : window as any;
  if (windowIfDefined && windowIfDefined.__REDUX_DEVTOOLS_EXTENSION__) {
    enhancers.push(windowIfDefined.__REDUX_DEVTOOLS_EXTENSION__() as any);
  }

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

reducers = combineReducers({
  projectId: reducerProjectId,
  settings: reducerSettings,
  conf: reducerConf,
  drafts: reducerDrafts,
  ideas: reducerIdeas,
  comments: reducerComments,
  users: reducerUsers,
  votes: reducerVotes,
  commentVotes: reducerCommentVotes,
  credits: reducerCredits,
  notifications: reducerNotifications,
  teammates: reducerTeammates,
  ...({
    loadingBar: loadingBarReducer,
  } as {}),
})

mainReducer = (state: any, action: Action) =>
	combineReducers({
		explainedVariable,
		// We need to access the `rules` in the simulation reducer
		simulation: (a: Simulation | null = null, b: Action): Simulation | null =>
			simulation(a, b),
		previousSimulation: defaultTo(null) as Reducer<SavedSimulation | null>,
		situationBranch,
		rules,
		actionChoices,
		conference,
		survey,
		iframeOptions: defaultTo(null),
		tutorials,
		storedTrajets,
		thenRedirectTo,
		tracking,
	})(state, action)

rootReducer = combineReducers({
  bookmarks: bookmarksReducer,
  navigation: navigationReducer,
  editing: editingReducer,
  auth: authReducer,
  backup: backupReducer,
  tags: tagsReducer,
  settings: settingsReducer,
})

constructor(app: App) {
    this.app = app;
    this.app.on("ready", this.onReady);
    this.app.on("window-all-closed", this.onWindowAllClosed);

    const packageJson = fs.readFileSync(packageJsonPath);
    const packageJsonObject = JSON.parse(packageJson.toString("utf-8"));

    this.version = packageJsonObject.version;

    this.bouyomiChan = new BouyomiChan({
      port: this.bouyomiChanPort,
    });

    const initialState = resumeData();
    this.isAlwaysOnTop = !!initialState.isAlwaysOnTop;
    this.serverRunning = !!initialState.fixedChatUrl;
    const reducer = combineReducers({ app: createAppReducer(initialState), chat: createChatReducer(chatInitialState) });

    const myCreateStore = compose(applyMiddleware(MainProcessMiddleware()))(createStore);

    this.store = myCreateStore(reducer);
  }

reducers = combineReducers({
  router: connectRouter(history),
  [PROVIDER_REDUCER_ID]: provider,
  [SAFE_REDUCER_ID]: safe,
  [NFT_ASSETS_REDUCER_ID]: nftAssetReducer,
  [NFT_TOKENS_REDUCER_ID]: nftTokensReducer,
  [TOKEN_REDUCER_ID]: tokens,
  [TRANSACTIONS_REDUCER_ID]: transactions,
  [CANCELLATION_TRANSACTIONS_REDUCER_ID]: cancellationTransactions,
  [INCOMING_TRANSACTIONS_REDUCER_ID]: incomingTransactions,
  [MODULE_TRANSACTIONS_REDUCER_ID]: moduleTransactions,
  [NOTIFICATIONS_REDUCER_ID]: notifications,
  [CURRENCY_VALUES_KEY]: currencyValues,
  [COOKIES_REDUCER_ID]: cookies,
  [ADDRESS_BOOK_REDUCER_ID]: addressBook,
  [CURRENT_SESSION_REDUCER_ID]: currentSession,
  [TRANSACTIONS]: allTransactions,
})

store = (() => {
	const store = createStore(
		combineReducers({
			router: connectRouter(history),
			app: rootReducer(defaultState)
		}),
		compose(
			applyMiddleware(routerMiddleware(history), ...middlewares),
			...(process.env.NODE_ENV === 'development' && devtools
				? [devtools()]
				: [])
		)
	)

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

	return store
})()

constructor() {
    // this is the rootReducer for the application.
    this._rootReducer = combineReducers<RootState>({
      switchIModelState: AppReducer,
      frameworkState: FrameworkReducer,
    } as any);

    // create the Redux Store.
    this._store = createStore(this._rootReducer,
      (window as any).__REDUX_DEVTOOLS_EXTENSION__ && (window as any).__REDUX_DEVTOOLS_EXTENSION__());
  }

rootReducer = combineReducers({
    auth: authReducer,
    error: errorReducer,
    loading: loadingReducer,
    newsFeed: newsFeedReducer,
    profile: profileReducer,
    chats: chatReducer,
    helper: helperReducer,
    modal: modalReducer,
    settings: settingsReducer,
})

rootReducer = combineReducers({
  header: headerReducer,
  dnd: dndReducer,
  modal: modalReducer,
  groups: undoable(groupsReducer, {
    filter: excludeAction(EXCLUDED_ACTIONS),
    groupBy: (actionType) => {
      const matchType = DND_GROUPING[DND_GROUPING.length - 1];
      const groupingId = DND_GROUPING.includes(actionType.type) ? matchType + "-" + randomGroupPostfix : null;

      // Want to update the random postfix after the final group's `groupingId` is updated
      if (actionType.type === matchType) {
        randomGroupPostfix = Math.random();
      }

      return groupingId;
    },
    syncFilter: true
  })
})

private getReducer(): reducer {
    let reducers: reducers = {};
    for (let m of this._models) {
      // m是每个model的配置
      reducers[m.namespace] = function (state = m.state, action) {
        // 组织每个模块的reducer
        let everyreducers = m.reducers; // reducers的配置对象，里面是函数
        let reducer = everyreducers[action.type]; // 相当于以前写的switch
        if (reducer) {
          return reducer(state, action);
        }
        return state;
      };
    }
    let extraReducers = this.plugin.get('extraReducers');
    return combineReducers({ ...reducers, ...extraReducers }); //reducer结构{reducer1:fn,reducer2:fn}
  }

rootReducer = () =>
  combineReducers({
    // BEGIN reducers from auspice
    metadata,
    tree,
    frequencies,
    controls,
    entropy,
    browserDimensions,
    notifications,
    narrative,
    treeToo,
    general: auspiceGeneralReducer,
    query: auspiceQueryReducer,
    measurements,
    // END reducers from auspice
  })

createRootReducer = (history: History) =>
  combineReducers({
    router: connectRouter(history),
    account,
    application,
    auction,
    logs,
    pastAuctions,
    onDisplayAuction,
  })

reducers = (history: any) =>
  combineReducers({
    router: connectRouter(history),
    auth,
    loading,
    users,
    toaster,
    drawer,
    progressBar,
    serviceWorker,
  })

root = (state: State, action: AnyAction): State => {
  switch (action.type) {
    case HYDRATE:
      return { ...state, ...action.payload } as State
  }

  const combined = combineReducers({
    auth,
  })

  return combined(state, action)
}

rootReducer = combineReducers({
  cta: ctaReducer,
  alert: alertReducer,
  device: deviceReducer,
  appConfig: appConfigReducer,
  weather: weatherReducer,
  feeds: feedsReducer,
  userSettings: userSettingsReducer,
  skeletonMenu: skeletonMenuReducer,
  fileList: fileListReducer,
  radios: radiosReducer,
})

rootReducer = combineReducers({
  auth: authReducer,
  theme: themeReducer,
  storage: storageReducer,
  globals: globalsReducer,
  leaveUsage: leaveUsageReducer,
  applyLeave: applyLeaveReducer,
  leaveList: leaveListReducer,
  assignLeave: assignLeaveReducer,
  leaveCommon: leaveCommonReducer,
  punch: punchReducer,
  attendance: attendanceReducer,
  help: helpConfigReducer,
})

// eslint-disable-next-line import/no-cycle
// import counterReducer from './features/counter/counterSlice';

export default function createRootReducer(history: History) {
  return combineReducers({
    router: connectRouter(history),
    // counter: counterReducer,
  });
}

storeConfig = {
  models,
  redux: {
    // @ts-ignore
    combineReducers: reducers => {
      return combineReducers({
        ...reducers,
        components: persistReducer(
          persistConfig,
          undoable(reducers.components, {
            limit: 10,
            filter: filterUndoableActions,
          }),
        ),
      })
    },
  },
  plugins: [persistPlugin],
}

createReducer = (): Reducer =>
  combineReducers({
    modal: modalReducer,
    loading: loadingReducer,
    userContext: userContextReducer,
    environment: environmentReducer,
    simulator: simulatorReducer,
    availableCustomTypes: availableCustomTypesReducer,
    selectedCustomType: selectedCustomTypeReducer,
    slices: slicesReducer,
    router: routerReducer,
  })

rootReducer = combineReducers({
    app,
    bootloader,
    ble,
    editor,
    explorer,
    fileStorage,
    firmware,
    hub,
})

createRootReducer = () => {
  const appReducer = combineReducers({
    ...rootReducers,
    ...addedReducers,
  });

  return (state: any, action: AnyAction): any => {
    if (action.type !== cleanUpAction.type) {
      return appReducer(state, action);
    }

    const { stateSelector } = action.payload as CleanUp<any>;
    const stateSlice = stateSelector(state);
    recursiveCleanState(state, stateSlice);

    return appReducer(state, action);
  };
}