@reduxjs/toolkit#createSelector TypeScript Examples

selectedEvents = createSelector(
  (events?: string[]) => events,
  (events?: string[]) =>
    events?.reduce(
      (acc: { names: string[]; eventKeys: string[] }, curr) => {
        if (/\.\*$/.test(curr)) {
          const val = curr.replace(/\.\*$/, '');
          !acc.names.includes(val) && acc.names.push(val);
        } else if (!acc.eventKeys.includes(curr)) {
          acc.eventKeys.push(curr);
        }
        return acc;
      },
      { names: [], eventKeys: [] }
    )
)

moodIdsByDateSelector = createSelector(
  normalizedMoodsSelector,
  ({ allIds }): { [date: string]: string[] | undefined } => {
    const moodsGroupedByDate: { [date: string]: string[] } = {};

    for (let i = 0; i < allIds.length; i++) {
      const id = allIds[i];
      const key = formatIsoDateInLocalTimezone(new Date(id));
      if (moodsGroupedByDate[key]) moodsGroupedByDate[key].push(id);
      else moodsGroupedByDate[key] = [id];
    }

    return moodsGroupedByDate;
  }
)

balancesWithTokensSelector = createSelector(
  (s: AppState) => s.tokens.byAddress,
  (s: AppState) => s.balances.accountBalances,
  (customTokens, accountBalances) => {
    const allTokens = { ...customTokens, ...NativeTokensByAddress }
    return {
      ...accountBalances,
      tokenAddrToToken: getMergedTokenBalances(allTokens, accountBalances.tokenAddrToValue),
    }
  }
)

uncompressedSiteImages = createSelector(
	selectActiveSite,
	(siteState) =>
		siteState
			? Object.values(siteState.imageData).filter(
				(d) => !d.compressedImageHash && !d.errorMessage,
			)
			: [],
)

getNightForSelectedDate = createSelector(
  [getNights, getSelectedDate, (state) => state.source.source],
  (nights, selectedDate, tracker) => {
    return nights
      .filter((night) => {
        return night.sourceId === tracker
      })
      .filter((night) => {
        return matchDayAndNight(night.startDate, selectedDate)
      })
  }
)

selectDownloadedTracks = (trackIds: EntityId[]) => (
    createSelector(
        selectAllDownloads,
        ({ entities, ids }) => {
            return intersection(trackIds, ids)
                .filter((id) => entities[id]?.isComplete);
        }
    )
)

selectTheme = createSelector(
  [(state: RootState) => state.theme || initialState],
  theme => {
    if (theme.selected === 'system') {
      return isSystemDark ? themes.dark : themes.light;
    }
    return themes[theme.selected];
  },
)

makeDataviewTreeSelector = () =>
  createSelector(
    [
      dataviewsSelector,
      (_, getSelectable: (o: ChartDataView) => boolean) => getSelectable,
    ],
    (dataviews, getSelectable) =>
      listToTree(dataviews, null, [ResourceTypes.View], { getSelectable }),
  )

selectClientData = createSelector(
    [selectDomain],
    selectDomain => selectDomain,
)

selectCurrentThemeMap = createSelector(
  [selectTheme, selectThemesMap],
  (theme, themesMap) => themesMap[theme] as ThemeMap | undefined
)

getAccountState = createSelector(baseInfo, account => account)

getAccountState = createSelector(baseInfo, account => account)

getAccountState = createSelector(baseInfo, account => account)

selectAccounts = createSelector(selectAdminState, (state) => state.accounts)

normalizedMeditationsSelector = createSelector(
  trackedCategoriesSelector,
  ({ meditations }): NormalizedMeditations => meditations
)

balanceEmptySelector = createSelector(
  (s: AppState) => s.balances.accountBalances,
  (balances) => areBalancesEmpty(balances)
)

downloadableSelector = createSelector(
  (store: IStoreState) => store.download.processing,
  (store: IStoreState) => store.interface.maxDownloadCount,
  (processing, maxDownloadCount) => {
    return processing < maxDownloadCount
  }
)

activeSiteID = createSelector(
	() => store.getState(),
	({ activeSiteID }) => activeSiteID,
)

getSelectedDate = createSelector(
  (state: RootState) => state.calendar.selectedDay,
  (date) => date
)