@reduxjs/toolkit#createSelector JavaScript Examples

selectTopicsUnderCategory = createSelector(
  selectDiscussionProvider,
  selectBlocks,
  state => state.topics.topicsInCategory,
  (provider, blocks, topicsInCategory) => (
    provider === DiscussionProvider.LEGACY
      ? category => topicsInCategory?.[category]
      : category => blocks[category]?.topics
  ),
)

hasAnyHighlightedRecordInScope = createSelector(
  [allRecordsWithFilterResponseSelector],
  (items) => !!items.find(({
    passesFilters: {
      type,
      date,
      // inCollection,
      showCollectionOnly,
      isHighlighted,
      // showHighlightedOnly,
    },
  }) => type && date && showCollectionOnly && isHighlighted),
)

selectCoursewareTopics = createSelector(
  selectDiscussionProvider,
  selectCategories,
  selectTopicCategoryMap,
  selectTopics,
  selectSequences,
  (provider, categoryIds, topicsInCategory, topics, sequences) => (
    provider === DiscussionProvider.LEGACY
      ? categoryIds.map(category => ({
        id: category,
        name: category,
        topics: topicsInCategory[category].map(id => topics[id]),
      }))
      : sequences.map(sequence => ({
        id: sequence.id,
        name: sequence.displayName,
        topics: sequence.topics.map(topicId => ({ id: topicId, name: topics[topicId].name })),
      }))
  ),
)

recordsFilteredByAllButDateSelector = createSelector(
  [allRecordsWithFilterResponseSelector],
  (items) => items.filter(({
    passesFilters: {
      type,
      showCollectionOnly,
      showHighlightedOnly,
    },
  }) => type && showCollectionOnly && showHighlightedOnly),
)

selectUserPosts = createSelector(
    [selectAllPosts, (state, username) => username],
    (posts, username) =>
        posts.filter(
            post =>
                post.user.screen_name === username ||
                (post.retweeted_by && post.retweeted_by.screen_name === username)
        )
)

providersSelector = createSelector(
  [resourcesSelector],
  (resources) => values(resources).filter((r) => r.type === 'Organization'),
)

selectCourseTitle = (code) =>
  createSelector(
    selectCourseListMinified,
    (courseListMinified) =>
      courseListMinified.find((course) => course.code === code)?.title ?? ''
  )

stateSelector = createSelector(makeSelectLocale(), (locale) => ({
  locale,
}))

selectAllLearners = createSelector(
  state => state.learners.pages,
  pages => pages.flat(),
)

selectPostById = createSelector(
    [selectAllPosts, (state, postId) => postId],
    (posts, postId) => posts.find(post => post.id_str === postId)
)

selectorForUnitSubsection = createSelector(
  selectBlocks,
  blocks => key => blocks[blocks[key]?.parent],
)

activeCollectionSelector = createSelector(
  [collectionsSelector, activeCollectionIdSelector],
  (collections, activeCollectionId) => collections[activeCollectionId],
)

selectUnread = createSelector([notifySelectors.selectAll], all =>
    all.filter(one => !one.read)
)

patientSelector = createSelector(
  [resourcesSelector],
  (resources) => values(resources).find((r) => r.type === 'Patient'),
)

selectAllThreads = createSelector(
  [
    state => state.threads.pages,
    selectThreads,
  ],
  (pages, threads) => pages.flatMap(ids => mapIdsToThreads(ids, threads)),
)

timelineIntervalsSelector = createSelector(
  [
    filteredRecordsSelector, timelineRangeSelector, activeCollectionSelector, resourcesSelector], // eslint-disable-line max-len
  (filteredItemsInDateRange, timelineRange, activeCollection, resources) => {
    const { records } = activeCollection;

    let intervals = [];
    let intervalLength = 0;
    let maxCount1SD = 0; // up to mean + 1 SD
    let maxCount2SD = 0; // up to mean + 2 SD
    let maxCount = 0; // beyond mean + 2 SD
    let recordCount1SD = 0;
    let recordCount2SD = 0;
    let recordCount2SDplus = 0;

    const { dateRangeStart: minDate, dateRangeEnd: maxDate } = timelineRange;
    // alternatively:
    // const minDate = filteredItemsInDateRange[0]?.timelineDate;
    // const maxDate = filteredItemsInDateRange[filteredItemsInDateRange.length - 1]?.timelineDate;

    if (minDate && maxDate && filteredItemsInDateRange.length) {
      const numDays = Math.max(differenceInDays(maxDate, minDate), 1);
      const intervalCount = Math.min(numDays, MAX_INTERVAL_COUNT); // cannot be 0

      const intervalMap = createIntervalMap(minDate, maxDate, intervalCount);
      const getNextIntervalForDate = generateNextIntervalFunc(intervalMap, intervalCount);

      filteredItemsInDateRange.forEach(({ id, timelineDate }) => {
        const currentInterval = getNextIntervalForDate(timelineDate);
        if (currentInterval) {
          currentInterval.items.push(id); // < mutates intervalMap
          if (currentInterval.items.length > maxCount) {
            maxCount = currentInterval.items.length;
          }
        } else {
          console.warn('no interval for date: ', timelineDate); // eslint-disable-line no-console
        }
      });
      intervals = intervalMap;

      intervalLength = numDays / intervalCount;
    }

    const intervalsWithItems = intervals.filter(({ items }) => items.length); // has items

    if (intervalsWithItems.length) {
      const itemCounts = intervalsWithItems.map(({ items }) => items.length);
      const totalItemCount = itemCounts.reduce((acc, count) => acc + count, 0);
      const meanCountPerInterval = totalItemCount / itemCounts.length;
      const sumOfSquaredDifferences = itemCounts
        .reduce((acc, count) => acc + ((count - meanCountPerInterval) ** 2), 0);

      const populationSD = (sumOfSquaredDifferences / itemCounts.length) ** 0.5;

      // inject z score, and markedItems -- mutates intervalMap:
      intervalsWithItems.forEach((interval) => {
        const cardinality = interval.items.length;
        // eslint-disable-next-line no-param-reassign
        interval.zScore = !populationSD ? 0 : (cardinality - meanCountPerInterval) / populationSD;
        // ^ mutates intervalMap
        if (interval.zScore <= 1 && cardinality > maxCount1SD) {
          maxCount1SD = cardinality;
          recordCount1SD += cardinality;
        } else if (interval.zScore <= 2 && cardinality > maxCount2SD) {
          maxCount2SD = cardinality;
          recordCount2SD += cardinality;
        } else if (interval.zScore > 2) {
          recordCount2SDplus += cardinality;
        }

        // temporary dictionary to group items by type:
        const markedItemsDictionaryByType = interval.items
          .filter((id) => records[id]?.highlight) // either MARKED or FOCUSED
          .reduce((acc, id) => {
            const { subType } = resources[id];
            const idsByType = acc[subType] ?? [];
            return {
              ...acc,
              [subType]: idsByType.concat(id),
            };
          }, {});

        // eslint-disable-next-line no-param-reassign
        interval.markedItems = Object.entries(markedItemsDictionaryByType)
          .sort(sortMarkedItemsBySubType) // keep cartouches in alphabetical order by subType label
          .map(([subType, items]) => ({
            subType,
            marked: items,
            focused: items.filter((id) => records[id]?.highlight === FOCUSED),
          }));

        // eslint-disable-next-line no-param-reassign
        interval.collectionItems = interval.items.filter((id) => records[id]?.saved);
      });
    }

    return {
      minDate,
      maxDate,
      intervalCount: intervals.length,
      intervals: intervals.filter(({ items }) => items.length),
      intervalLength,
      maxCount,
      maxCount1SD,
      maxCount2SD,
      recordCount: filteredItemsInDateRange.length,
      recordCount1SD,
      recordCount2SD,
      recordCount2SDplus,
    };
  },
)