app/javascript/mastodon/reducers/timelines.js

   1 import {
   2   TIMELINE_UPDATE,
   3   TIMELINE_DELETE,
   4   TIMELINE_CLEAR,
   5   TIMELINE_EXPAND_SUCCESS,
   6   TIMELINE_EXPAND_REQUEST,
   7   TIMELINE_EXPAND_FAIL,
   8   TIMELINE_SCROLL_TOP,
   9   TIMELINE_CONNECT,
  10   TIMELINE_DISCONNECT,
  11   TIMELINE_LOAD_PENDING,
  12   CURRENTLY_VIEWING,
  13 } from '../actions/timelines';
  14 import {
  15   ACCOUNT_BLOCK_SUCCESS,
  16   ACCOUNT_MUTE_SUCCESS,
  17   ACCOUNT_UNFOLLOW_SUCCESS,
  18 } from '../actions/accounts';
  19 import { Map as ImmutableMap, List as ImmutableList, fromJS } from 'immutable';
  20 import compareId from '../compare_id';
  21
  22 const initialState = ImmutableMap();
  23
  24 const initialTimeline = ImmutableMap({
  25   unread: 0,
  26   online: false,
  27   top: true,
  28   isLoading: false,
  29   hasMore: true,
  30   pendingItems: ImmutableList(),
  31   items: ImmutableList(),
  32   currentlyViewing: -1,
  33 });
  34
  35 const expandNormalizedTimeline = (state, timeline, statuses, next, isPartial, isLoadingRecent, usePendingItems) => {
  36   return state.update(timeline, initialTimeline, map => map.withMutations(mMap => {
  37     mMap.set('isLoading', false);
  38     mMap.set('isPartial', isPartial);
  39
  40     if (!next && !isLoadingRecent) mMap.set('hasMore', false);
  41
  42     if (timeline.endsWith(':pinned')) {
  43       mMap.set('items', statuses.map(status => status.get('id')));
  44     } else if (!statuses.isEmpty()) {
  45       usePendingItems = isLoadingRecent && (usePendingItems || !mMap.get('pendingItems').isEmpty());
  46
  47       mMap.update(usePendingItems ? 'pendingItems' : 'items', ImmutableList(), oldIds => {
  48         const newIds = statuses.map(status => status.get('id'));
  49
  50         const lastIndex = oldIds.findLastIndex(id => id !== null && compareId(id, newIds.last()) >= 0) + 1;
  51         const firstIndex = oldIds.take(lastIndex).findLastIndex(id => id !== null && compareId(id, newIds.first()) > 0);
  52
  53         if (firstIndex < 0) {
  54           return (isPartial ? newIds.unshift(null) : newIds).concat(oldIds.skip(lastIndex));
  55         }
  56
  57         return oldIds.take(firstIndex + 1).concat(
  58           isPartial && oldIds.get(firstIndex) !== null ? newIds.unshift(null) : newIds,
  59           oldIds.skip(lastIndex)
  60         );
  61       });
  62     }
  63   }));
  64 };
  65
  66 const updateTimeline = (state, timeline, status, usePendingItems) => {
  67   const top = state.getIn([timeline, 'top']);
  68
  69   if (usePendingItems || !state.getIn([timeline, 'pendingItems']).isEmpty()) {
  70     if (state.getIn([timeline, 'pendingItems'], ImmutableList()).includes(status.get('id')) || state.getIn([timeline, 'items'], ImmutableList()).includes(status.get('id'))) {
  71       return state;
  72     }
  73
  74     return state.update(timeline, initialTimeline, map => map.update('pendingItems', list => list.unshift(status.get('id'))).update('unread', unread => unread + 1));
  75   }
  76
  77   const ids        = state.getIn([timeline, 'items'], ImmutableList());
  78   const includesId = ids.includes(status.get('id'));
  79   const unread     = state.getIn([timeline, 'unread'], 0);
  80
  81   if (includesId) {
  82     return state;
  83   }
  84
  85   let newIds = ids;
  86
  87   return state.update(timeline, initialTimeline, map => map.withMutations(mMap => {
  88     if (!top) mMap.set('unread', unread + 1);
  89     if (top && ids.size > 40) newIds = newIds.take(20);
  90     mMap.set('items', newIds.unshift(status.get('id')));
  91   }));
  92 };
  93
  94 const deleteStatus = (state, id, accountId, references, exclude_account = null) => {
  95   state.keySeq().forEach(timeline => {
  96     if (exclude_account === null || (timeline !== `account:${exclude_account}` && !timeline.startsWith(`account:${exclude_account}:`))) {
  97       const helper = list => list.filterNot(item => item === id);
  98       state = state.updateIn([timeline, 'items'], helper).updateIn([timeline, 'pendingItems'], helper);
  99     }
 100   });
 101
 102   // Remove reblogs of deleted status
 103   references.forEach(ref => {
 104     state = deleteStatus(state, ref[0], ref[1], [], exclude_account);
 105   });
 106
 107   return state;
 108 };
 109
 110 const clearTimeline = (state, timeline) => {
 111   return state.set(timeline, initialTimeline);
 112 };
 113
 114 const filterTimelines = (state, relationship, statuses) => {
 115   let references;
 116
 117   statuses.forEach(status => {
 118     if (status.get('account') !== relationship.id) {
 119       return;
 120     }
 121
 122     references = statuses.filter(item => item.get('reblog') === status.get('id')).map(item => [item.get('id'), item.get('account')]);
 123     state      = deleteStatus(state, status.get('id'), status.get('account'), references, relationship.id);
 124   });
 125
 126   return state;
 127 };
 128
 129 const filterTimeline = (timeline, state, relationship, statuses) => {
 130   const helper = list => list.filterNot(statusId => statuses.getIn([statusId, 'account']) === relationship.id);
 131   return state.updateIn([timeline, 'items'], ImmutableList(), helper).updateIn([timeline, 'pendingItems'], ImmutableList(), helper);
 132 };
 133
 134 const updateTop = (state, timeline, top) => {
 135   return state.update(timeline, initialTimeline, map => map.withMutations(mMap => {
 136     if (top) mMap.set('unread', mMap.get('pendingItems').size);
 137     mMap.set('top', top);
 138   }));
 139 };
 140
 141 export default function timelines(state = initialState, action) {
 142   switch(action.type) {
 143   case TIMELINE_LOAD_PENDING:
 144     return state.update(action.timeline, initialTimeline, map =>
 145       map.update('items', list => map.get('pendingItems').concat(list.take(40))).set('pendingItems', ImmutableList()).set('unread', 0));
 146   case TIMELINE_EXPAND_REQUEST:
 147     return state.update(action.timeline, initialTimeline, map => map.set('isLoading', true));
 148   case TIMELINE_EXPAND_FAIL:
 149     return state.update(action.timeline, initialTimeline, map => map.set('isLoading', false));
 150   case TIMELINE_EXPAND_SUCCESS:
 151     return expandNormalizedTimeline(state, action.timeline, fromJS(action.statuses), action.next, action.partial, action.isLoadingRecent, action.usePendingItems);
 152   case TIMELINE_UPDATE:
 153     return updateTimeline(state, action.timeline, fromJS(action.status), action.usePendingItems);
 154   case TIMELINE_DELETE:
 155     return deleteStatus(state, action.id, action.accountId, action.references, action.reblogOf);
 156   case TIMELINE_CLEAR:
 157     return clearTimeline(state, action.timeline);
 158   case ACCOUNT_BLOCK_SUCCESS:
 159   case ACCOUNT_MUTE_SUCCESS:
 160     return filterTimelines(state, action.relationship, action.statuses);
 161   case ACCOUNT_UNFOLLOW_SUCCESS:
 162     return filterTimeline('home', state, action.relationship, action.statuses);
 163   case TIMELINE_SCROLL_TOP:
 164     return updateTop(state, action.timeline, action.top);
 165   case TIMELINE_CONNECT:
 166     return state.update(action.timeline, initialTimeline, map => map.set('online', true));
 167   case TIMELINE_DISCONNECT:
 168     return state.update(
 169       action.timeline,
 170       initialTimeline,
 171       map => map.set('online', false).update(action.usePendingItems ? 'pendingItems' : 'items', items => items.first() ? items.unshift(null) : items)
 172     );
 173   case CURRENTLY_VIEWING:
 174     return state.update(action.timeline, initialTimeline, map => map.set('currentlyViewing', action.id));
 175   default:
 176     return state;
 177   }
 178 };