mirror_maker
/
soapbox
mirror of https://gitlab.com/soapbox-pub/soapbox
1
0
Fork 1
Code Issues Packages Projects Releases Wiki Activity

Timelines: big refactor, use Immutable.OrderedSet

Browse Source
merge-requests/585/head
Alex Gleason 3 years ago
parent c5c1c24417
commit 2978745311
No known key found for this signature in database
GPG Key ID: 7211D1F99744FBB7
3 changed files with 141 additions and 102 deletions
Show Stats Download Patch File Download Diff File

6
app/soapbox/actions/timelines.js
Unescape View File

@ -1,6 +1,6 @@
import { importFetchedStatus, importFetchedStatuses } from './importer'; import { importFetchedStatus, importFetchedStatuses } from './importer';
import api, { getLinks } from '../api'; import api, { getLinks } from '../api';
import { Map as ImmutableMap, List as ImmutableList, fromJS } from 'immutable'; import { Map as ImmutableMap, OrderedSet as ImmutableOrderedSet, fromJS } from 'immutable';
import { getSettings } from 'soapbox/actions/settings'; import { getSettings } from 'soapbox/actions/settings';
import { shouldFilter } from 'soapbox/utils/timelines'; import { shouldFilter } from 'soapbox/utils/timelines';
@ -65,7 +65,7 @@ export function updateTimelineQueue(timeline, statusId, accept) {
export function dequeueTimeline(timeline, expandFunc, optionalExpandArgs) { export function dequeueTimeline(timeline, expandFunc, optionalExpandArgs) {
return (dispatch, getState) => { return (dispatch, getState) => {
const queuedItems = getState().getIn(['timelines', timeline, 'queuedItems'], ImmutableList()); const queuedItems = getState().getIn(['timelines', timeline, 'queuedItems'], ImmutableOrderedSet());
const totalQueuedItemsCount = getState().getIn(['timelines', timeline, 'totalQueuedItemsCount'], 0); const totalQueuedItemsCount = getState().getIn(['timelines', timeline, 'totalQueuedItemsCount'], 0);
let shouldDispatchDequeue = true; let shouldDispatchDequeue = true;
@ -142,7 +142,7 @@ export function expandTimeline(timelineId, path, params = {}, done = noOp) {
return; return;
} }
if (!params.max_id && !params.pinned && timeline.get('items', ImmutableList()).size > 0) { if (!params.max_id && !params.pinned && timeline.get('items', ImmutableOrderedSet()).size > 0) {
params.since_id = timeline.getIn(['items', 0]); params.since_id = timeline.getIn(['items', 0]);
} }

2
app/soapbox/components/status_list.js
Unescape View File

@ -17,7 +17,7 @@ export default class StatusList extends ImmutablePureComponent {
static propTypes = { static propTypes = {
scrollKey: PropTypes.string.isRequired, scrollKey: PropTypes.string.isRequired,
statusIds: ImmutablePropTypes.list.isRequired, statusIds: ImmutablePropTypes.orderedSet.isRequired,
lastStatusId: PropTypes.string, lastStatusId: PropTypes.string,
featuredStatusIds: ImmutablePropTypes.list, featuredStatusIds: ImmutablePropTypes.list,
onLoadMore: PropTypes.func, onLoadMore: PropTypes.func,

235
app/soapbox/reducers/timelines.js
Unescape View File

@ -17,8 +17,12 @@ import {
ACCOUNT_MUTE_SUCCESS, ACCOUNT_MUTE_SUCCESS,
ACCOUNT_UNFOLLOW_SUCCESS, ACCOUNT_UNFOLLOW_SUCCESS,
} from '../actions/accounts'; } from '../actions/accounts';
import { Map as ImmutableMap, List as ImmutableList, fromJS } from 'immutable'; import {
import compareId from '../compare_id'; Map as ImmutableMap,
List as ImmutableList,
OrderedSet as ImmutableOrderedSet,
fromJS,
} from 'immutable';
import { GROUP_REMOVE_STATUS_SUCCESS } from '../actions/groups'; import { GROUP_REMOVE_STATUS_SUCCESS } from '../actions/groups';
const initialState = ImmutableMap(); const initialState = ImmutableMap();
@ -29,139 +33,181 @@ const initialTimeline = ImmutableMap({
top: true, top: true,
isLoading: false, isLoading: false,
hasMore: true, hasMore: true,
items: ImmutableList(), items: ImmutableOrderedSet(),
queuedItems: ImmutableList(), //max= MAX_QUEUED_ITEMS queuedItems: ImmutableOrderedSet(), //max= MAX_QUEUED_ITEMS
totalQueuedItemsCount: 0, //used for queuedItems overflow for MAX_QUEUED_ITEMS+ totalQueuedItemsCount: 0, //used for queuedItems overflow for MAX_QUEUED_ITEMS+
}); });
const expandNormalizedTimeline = (state, timeline, statuses, next, isPartial, isLoadingRecent) => { const getStatusIds = (statuses = ImmutableList()) => (
return state.update(timeline, initialTimeline, map => map.withMutations(mMap => { statuses.map(status => status.get('id')).toOrderedSet()
mMap.set('isLoading', false); );
mMap.set('isPartial', isPartial);
const mergeStatusIds = (oldIds = ImmutableOrderedSet(), newIds = ImmutableOrderedSet()) => (
newIds.first() > oldIds.first() ? newIds.union(oldIds) : oldIds.union(newIds)
);
if (!next && !isLoadingRecent) mMap.set('hasMore', false); const addStatusId = (oldIds = ImmutableOrderedSet(), newId) => (
mergeStatusIds(oldIds, ImmutableOrderedSet([newId]))
);
if (!statuses.isEmpty()) { // Like `take`, but only if the collection's size exceeds truncateLimit
mMap.update('items', ImmutableList(), oldIds => { const truncate = (items, truncateLimit, newSize) => (
const newIds = statuses.map(status => status.get('id')); items.size > truncateLimit ? items.take(newSize) : items
);
if (timeline.indexOf(':pinned') !== -1) { const setLoading = (state, timelineId, loading) => {
return newIds; return state.update(timelineId, initialTimeline, timeline => timeline.set('isLoading', loading));
} };
const lastIndex = oldIds.findLastIndex(id => id !== null && compareId(id, newIds.last()) >= 0) + 1; const expandNormalizedTimeline = (state, timelineId, statuses, next, isPartial, isLoadingRecent) => {
const firstIndex = oldIds.take(lastIndex).findLastIndex(id => id !== null && compareId(id, newIds.first()) > 0); const newIds = getStatusIds(statuses);
if (firstIndex < 0) { return state.update(timelineId, initialTimeline, timeline => timeline.withMutations(timeline => {
return (isPartial ? newIds.unshift(null) : newIds).concat(oldIds.skip(lastIndex)); timeline.set('isLoading', false);
} timeline.set('isPartial', isPartial);
return oldIds.take(firstIndex + 1).concat( if (!next && !isLoadingRecent) timeline.set('hasMore', false);
isPartial && oldIds.get(firstIndex) !== null ? newIds.unshift(null) : newIds,
oldIds.skip(lastIndex), // Pinned timelines can be replaced entirely
); if (timelineId.endsWith(':pinned')) {
}); timeline.set('items', newIds);
return;
}
if (!newIds.isEmpty()) {
timeline.update('items', ImmutableOrderedSet(), oldIds => mergeStatusIds(oldIds, newIds));
} }
})); }));
}; };
const updateTimeline = (state, timeline, statusId) => { const updateTimeline = (state, timelineId, statusId) => {
const top = state.getIn([timeline, 'top']); const top = state.getIn([timelineId, 'top']);
const ids = state.getIn([timeline, 'items'], ImmutableList()); const oldIds = state.getIn([timelineId, 'items'], ImmutableOrderedSet());
const includesId = ids.includes(statusId); const unread = state.getIn([timelineId, 'unread'], 0);
const unread = state.getIn([timeline, 'unread'], 0);
if (includesId) { if (oldIds.includes(statusId)) return state;
return state;
}
let newIds = ids; const newIds = addStatusId(oldIds, statusId);
return state.update(timeline, initialTimeline, map => map.withMutations(mMap => { return state.update(timelineId, initialTimeline, timeline => timeline.withMutations(timeline => {
if (!top) mMap.set('unread', unread + 1); if (top) {
if (top && ids.size > 40) newIds = newIds.take(20); // For performance, truncate items if user is scrolled to the top
mMap.set('items', newIds.unshift(statusId)); timeline.set('items', truncate(newIds, 40, 20));
} else {
timeline.set('unread', unread + 1);
timeline.set('items', newIds);
}
})); }));
}; };
const updateTimelineQueue = (state, timeline, statusId) => { const updateTimelineQueue = (state, timelineId, statusId) => {
const queuedStatuses = state.getIn([timeline, 'queuedItems'], ImmutableList()); const queuedIds = state.getIn([timelineId, 'queuedItems'], ImmutableOrderedSet());
const listedStatuses = state.getIn([timeline, 'items'], ImmutableList()); const listedIds = state.getIn([timelineId, 'items'], ImmutableOrderedSet());
const totalQueuedItemsCount = state.getIn([timeline, 'totalQueuedItemsCount'], 0); const queuedCount = state.getIn([timelineId, 'totalQueuedItemsCount'], 0);
let alreadyExists = queuedStatuses.find(existingQueuedStatus => existingQueuedStatus === statusId); if (queuedIds.includes(statusId)) return state;
if (!alreadyExists) alreadyExists = listedStatuses.find(existingListedStatusId => existingListedStatusId === statusId); if (listedIds.includes(statusId)) return state;
if (alreadyExists) { return state.update(timelineId, initialTimeline, timeline => timeline.withMutations(timeline => {
return state; timeline.set('totalQueuedItemsCount', queuedCount + 1);
}
let newQueuedStatuses = queuedStatuses; if (queuedCount < MAX_QUEUED_ITEMS) {
timeline.set('queuedItems', addStatusId(queuedIds, statusId));
return state.update(timeline, initialTimeline, map => map.withMutations(mMap => {
if (totalQueuedItemsCount <= MAX_QUEUED_ITEMS) {
mMap.set('queuedItems', newQueuedStatuses.push(statusId));
} }
mMap.set('totalQueuedItemsCount', totalQueuedItemsCount + 1);
})); }));
}; };
const deleteStatus = (state, id, accountId, references, exclude_account = null) => { const shouldDelete = (timelineId, excludeAccount) => {
state.keySeq().forEach(timeline => { if (!excludeAccount) return true;
if (exclude_account === null || (timeline !== `account:${exclude_account}` && !timeline.startsWith(`account:${exclude_account}:`))) if (timelineId === `account:${excludeAccount}`) return false;
state = state.updateIn([timeline, 'items'], list => list.filterNot(item => item === id)); if (timelineId.startsWith(`account:${excludeAccount}:`)) return false;
}); return true;
};
// Remove reblogs of deleted status const deleteStatus = (state, statusId, accountId, references, excludeAccount = null) => {
references.forEach(ref => { return state.withMutations(state => {
state = deleteStatus(state, ref[0], ref[1], [], exclude_account); state.keySeq().forEach(timelineId => {
if (shouldDelete(timelineId, excludeAccount)) {
state.updateIn([timelineId, 'items'], ids => ids.delete(statusId));
state.updateIn([timelineId, 'queuedItems'], ids => ids.delete(statusId));
}
});
// Remove reblogs of deleted status
references.forEach(ref => {
deleteStatus(state, ref[0], ref[1], [], excludeAccount);
});
}); });
};
return state; const clearTimeline = (state, timelineId) => {
return state.set(timelineId, initialTimeline);
}; };
const clearTimeline = (state, timeline) => { const updateTop = (state, timelineId, top) => {
return state.set(timeline, initialTimeline); return state.update(timelineId, initialTimeline, timeline => timeline.withMutations(timeline => {
if (top) timeline.set('unread', 0);
timeline.set('top', top);
}));
}; };
const filterTimelines = (state, relationship, statuses) => { const isReblogOf = (reblog, status) => reblog.get('reblog') === status.get('id');
let references; const statusToReference = status => [status.get('id'), status.get('account')];
statuses.forEach(status => { const buildReferencesTo = (statuses, status) => (
if (status.get('account') !== relationship.id) { statuses
return; .filter(reblog => isReblogOf(reblog, status))
} .map(statusToReference)
);
const filterTimeline = (state, timelineId, relationship, statuses) =>
state.updateIn([timelineId, 'items'], ImmutableOrderedSet(), ids =>
ids.filterNot(statusId =>
statuses.getIn([statusId, 'account']) === relationship.id,
));
references = statuses.filter(item => item.get('reblog') === status.get('id')).map(item => [item.get('id'), item.get('account')]); const filterTimelines = (state, relationship, statuses) => {
state = deleteStatus(state, status.get('id'), status.get('account'), references, relationship.id); return state.withMutations(state => {
statuses.forEach(status => {
if (status.get('account') !== relationship.id) return;
const references = buildReferencesTo(statuses, status);
deleteStatus(state, status.get('id'), status.get('account'), references, relationship.id);
});
}); });
};
return state; const removeStatusFromGroup = (state, groupId, statusId) => {
return state.updateIn([`group:${groupId}`, 'items'], ImmutableOrderedSet(), ids => ids.delete(statusId));
}; };
const updateTop = (state, timeline, top) => { const timelineDequeue = (state, timelineId) => {
return state.update(timeline, initialTimeline, map => map.withMutations(mMap => { return state.update(timelineId, initialTimeline, timeline => timeline.withMutations(timeline => {
if (top) mMap.set('unread', 0); timeline.set('queuedItems', ImmutableOrderedSet());
mMap.set('top', top); timeline.set('totalQueuedItemsCount', 0);
})); }));
}; };
const filterTimeline = (timeline, state, relationship, statuses) => const timelineConnect = (state, timelineId) => {
state.updateIn([timeline, 'items'], ImmutableList(), list => return state.update(timelineId, initialTimeline, timeline => timeline.set('online', true));
list.filterNot(statusId => };
statuses.getIn([statusId, 'account']) === relationship.id,
));
const removeStatusFromGroup = (state, groupId, statusId) => { const timelineDisconnect = (state, timelineId) => {
return state.updateIn([`group:${groupId}`, 'items'], list => list.filterNot(item => item === statusId)); return state.update(timelineId, initialTimeline, timeline => timeline.withMutations(timeline => {
timeline.set('online', false);
const items = timeline.get('items', ImmutableOrderedSet());
if (items.isEmpty()) return;
timeline.set('items', addStatusId(items, null));
}));
}; };
export default function timelines(state = initialState, action) { export default function timelines(state = initialState, action) {
switch(action.type) { switch(action.type) {
case TIMELINE_EXPAND_REQUEST: case TIMELINE_EXPAND_REQUEST:
return state.update(action.timeline, initialTimeline, map => map.set('isLoading', true)); return setLoading(state, action.timeline, true);
case TIMELINE_EXPAND_FAIL: case TIMELINE_EXPAND_FAIL:
return state.update(action.timeline, initialTimeline, map => map.set('isLoading', false)); return setLoading(state, action.timeline, false);
case TIMELINE_EXPAND_SUCCESS: case TIMELINE_EXPAND_SUCCESS:
return expandNormalizedTimeline(state, action.timeline, fromJS(action.statuses), action.next, action.partial, action.isLoadingRecent); return expandNormalizedTimeline(state, action.timeline, fromJS(action.statuses), action.next, action.partial, action.isLoadingRecent);
case TIMELINE_UPDATE: case TIMELINE_UPDATE:
@ -169,10 +215,7 @@ export default function timelines(state = initialState, action) {
case TIMELINE_UPDATE_QUEUE: case TIMELINE_UPDATE_QUEUE:
return updateTimelineQueue(state, action.timeline, action.statusId); return updateTimelineQueue(state, action.timeline, action.statusId);
case TIMELINE_DEQUEUE: case TIMELINE_DEQUEUE:
return state.update(action.timeline, initialTimeline, map => map.withMutations(mMap => { return timelineDequeue(state, action.timeline);
mMap.set('queuedItems', ImmutableList());
mMap.set('totalQueuedItemsCount', 0);
}));
case TIMELINE_DELETE: case TIMELINE_DELETE:
return deleteStatus(state, action.id, action.accountId, action.references, action.reblogOf); return deleteStatus(state, action.id, action.accountId, action.references, action.reblogOf);
case TIMELINE_CLEAR: case TIMELINE_CLEAR:
@ -181,17 +224,13 @@ export default function timelines(state = initialState, action) {
case ACCOUNT_MUTE_SUCCESS: case ACCOUNT_MUTE_SUCCESS:
return filterTimelines(state, action.relationship, action.statuses); return filterTimelines(state, action.relationship, action.statuses);
case ACCOUNT_UNFOLLOW_SUCCESS: case ACCOUNT_UNFOLLOW_SUCCESS:
return filterTimeline('home', state, action.relationship, action.statuses); return filterTimeline(state, 'home', action.relationship, action.statuses);
case TIMELINE_CONNECT:
return state.update(action.timeline, initialTimeline, map => map.set('online', true));
case TIMELINE_SCROLL_TOP: case TIMELINE_SCROLL_TOP:
return updateTop(state, action.timeline, action.top); return updateTop(state, action.timeline, action.top);
case TIMELINE_CONNECT:
return timelineConnect(state, action.timeline);
case TIMELINE_DISCONNECT: case TIMELINE_DISCONNECT:
return state.update( return timelineDisconnect(state, action.timeline);
action.timeline,
initialTimeline,
map => map.set('online', false).update('items', items => items.first() ? items.unshift(null) : items),
);
case GROUP_REMOVE_STATUS_SUCCESS: case GROUP_REMOVE_STATUS_SUCCESS:
return removeStatusFromGroup(state, action.groupId, action.id); return removeStatusFromGroup(state, action.groupId, action.id);
default: default:

Write Preview
Loading…
Cancel
Save