import api, { getLinks } from '../api';
-import Immutable from 'immutable';
+import { List as ImmutableList } from 'immutable';
import IntlMessageFormat from 'intl-messageformat';
import { fetchRelationships } from './accounts';
import { defineMessages } from 'react-intl';
export function expandNotifications() {
return (dispatch, getState) => {
- const items = getState().getIn(['notifications', 'items'], Immutable.List());
+ const items = getState().getIn(['notifications', 'items'], ImmutableList());
if (getState().getIn(['notifications', 'isLoading']) || items.size === 0) {
return;
-import Immutable from 'immutable';
+import { Iterable, fromJS } from 'immutable';
export const STORE_HYDRATE = 'STORE_HYDRATE';
export const STORE_HYDRATE_LAZY = 'STORE_HYDRATE_LAZY';
const convertState = rawState =>
- Immutable.fromJS(rawState, (k, v) =>
- Immutable.Iterable.isIndexed(v) ? v.toList() : v.toMap().mapKeys(x =>
+ fromJS(rawState, (k, v) =>
+ Iterable.isIndexed(v) ? v.toList() : v.toMap().mapKeys(x =>
Number.isNaN(x * 1) ? x : x * 1));
export function hydrateStore(rawState) {
import api, { getLinks } from '../api';
-import Immutable from 'immutable';
+import { Map as ImmutableMap, List as ImmutableList } from 'immutable';
export const TIMELINE_UPDATE = 'TIMELINE_UPDATE';
export const TIMELINE_DELETE = 'TIMELINE_DELETE';
export function refreshTimeline(timelineId, path, params = {}) {
return function (dispatch, getState) {
- const timeline = getState().getIn(['timelines', timelineId], Immutable.Map());
+ const timeline = getState().getIn(['timelines', timelineId], ImmutableMap());
if (timeline.get('isLoading') || timeline.get('online')) {
return;
}
- const ids = timeline.get('items', Immutable.List());
+ const ids = timeline.get('items', ImmutableList());
const newestId = ids.size > 0 ? ids.first() : null;
let skipLoading = timeline.get('loaded');
export function expandTimeline(timelineId, path, params = {}) {
return (dispatch, getState) => {
- const timeline = getState().getIn(['timelines', timelineId], Immutable.Map());
- const ids = timeline.get('items', Immutable.List());
+ const timeline = getState().getIn(['timelines', timelineId], ImmutableMap());
+ const ids = timeline.get('items', ImmutableList());
if (timeline.get('isLoading') || ids.size === 0) {
return;
import Column from '../ui/components/column';
import HeaderContainer from './containers/header_container';
import ColumnBackButton from '../../components/column_back_button';
-import Immutable from 'immutable';
+import { List as ImmutableList } from 'immutable';
import ImmutablePureComponent from 'react-immutable-pure-component';
const mapStateToProps = (state, props) => ({
- statusIds: state.getIn(['timelines', `account:${Number(props.params.accountId)}`, 'items'], Immutable.List()),
+ statusIds: state.getIn(['timelines', `account:${Number(props.params.accountId)}`, 'items'], ImmutableList()),
isLoading: state.getIn(['timelines', `account:${Number(props.params.accountId)}`, 'isLoading']),
hasMore: !!state.getIn(['timelines', `account:${Number(props.params.accountId)}`, 'next']),
me: state.getIn(['meta', 'me']),
import { defineMessages, injectIntl, FormattedMessage } from 'react-intl';
import ColumnSettingsContainer from './containers/column_settings_container';
import { createSelector } from 'reselect';
-import Immutable from 'immutable';
+import { List as ImmutableList } from 'immutable';
import LoadMore from '../../components/load_more';
import { debounce } from 'lodash';
});
const getNotifications = createSelector([
- state => Immutable.List(state.getIn(['settings', 'notifications', 'shows']).filter(item => !item).keys()),
+ state => ImmutableList(state.getIn(['settings', 'notifications', 'shows']).filter(item => !item).keys()),
state => state.getIn(['notifications', 'items']),
], (excludedTypes, notifications) => notifications.filterNot(item => excludedTypes.includes(item.get('type'))));
import { connect } from 'react-redux';
import StatusCheckBox from '../components/status_check_box';
import { toggleStatusReport } from '../../../actions/reports';
-import Immutable from 'immutable';
+import { Set as ImmutableSet } from 'immutable';
const mapStateToProps = (state, { id }) => ({
status: state.getIn(['statuses', id]),
- checked: state.getIn(['reports', 'new', 'status_ids'], Immutable.Set()).includes(id),
+ checked: state.getIn(['reports', 'new', 'status_ids'], ImmutableSet()).includes(id),
});
const mapDispatchToProps = (dispatch, { id }) => ({
import Search from '../../compose/components/search';
import NavigationBar from '../../compose/components/navigation_bar';
import ColumnHeader from './column_header';
-import Immutable from 'immutable';
+import { List as ImmutableList } from 'immutable';
const noop = () => { };
</div>
<ComposeForm
text='Awoo! #introductions'
- suggestions={Immutable.List()}
+ suggestions={ImmutableList()}
mentionedDomains={[]}
spoiler={false}
onChange={noop}
import { makeGetAccount } from '../../../selectors';
import { defineMessages, FormattedMessage, injectIntl } from 'react-intl';
import StatusCheckBox from '../../report/containers/status_check_box_container';
-import Immutable from 'immutable';
+import { OrderedSet } from 'immutable';
import ImmutablePureComponent from 'react-immutable-pure-component';
import Button from '../../../components/button';
isSubmitting: state.getIn(['reports', 'new', 'isSubmitting']),
account: getAccount(state, accountId),
comment: state.getIn(['reports', 'new', 'comment']),
- statusIds: Immutable.OrderedSet(state.getIn(['timelines', `account:${accountId}`, 'items'])).union(state.getIn(['reports', 'new', 'status_ids'])),
+ statusIds: OrderedSet(state.getIn(['timelines', `account:${accountId}`, 'items'])).union(state.getIn(['reports', 'new', 'status_ids'])),
};
};
import { connect } from 'react-redux';
import StatusList from '../../../components/status_list';
import { scrollTopTimeline } from '../../../actions/timelines';
-import Immutable from 'immutable';
+import { Map as ImmutableMap, List as ImmutableList } from 'immutable';
import { createSelector } from 'reselect';
import { debounce } from 'lodash';
const makeGetStatusIds = () => createSelector([
- (state, { type }) => state.getIn(['settings', type], Immutable.Map()),
- (state, { type }) => state.getIn(['timelines', type, 'items'], Immutable.List()),
+ (state, { type }) => state.getIn(['settings', type], ImmutableMap()),
+ (state, { type }) => state.getIn(['timelines', type, 'items'], ImmutableList()),
(state) => state.get('statuses'),
(state) => state.getIn(['meta', 'me']),
], (columnSettings, statusIds, statuses, me) => statusIds.filter(id => {
FAVOURITED_STATUSES_EXPAND_SUCCESS,
} from '../actions/favourites';
import { STORE_HYDRATE } from '../actions/store';
-import Immutable from 'immutable';
+import { Map as ImmutableMap, fromJS } from 'immutable';
const normalizeAccount = (state, account) => {
account = { ...account };
delete account.following_count;
delete account.statuses_count;
- return state.set(account.id, Immutable.fromJS(account));
+ return state.set(account.id, fromJS(account));
};
const normalizeAccounts = (state, accounts) => {
return state;
};
-const initialState = Immutable.Map();
+const initialState = ImmutableMap();
export default function accounts(state = initialState, action) {
switch(action.type) {
FAVOURITED_STATUSES_EXPAND_SUCCESS,
} from '../actions/favourites';
import { STORE_HYDRATE } from '../actions/store';
-import Immutable from 'immutable';
+import { Map as ImmutableMap, fromJS } from 'immutable';
-const normalizeAccount = (state, account) => state.set(account.id, Immutable.fromJS({
+const normalizeAccount = (state, account) => state.set(account.id, fromJS({
followers_count: account.followers_count,
following_count: account.following_count,
statuses_count: account.statuses_count,
return state;
};
-const initialState = Immutable.Map();
+const initialState = ImmutableMap();
export default function accountsCounters(state = initialState, action) {
switch(action.type) {
case STORE_HYDRATE:
- return state.merge(action.state.get('accounts').map(item => Immutable.fromJS({
+ return state.merge(action.state.get('accounts').map(item => fromJS({
followers_count: item.get('followers_count'),
following_count: item.get('following_count'),
statuses_count: item.get('statuses_count'),
ALERT_DISMISS,
ALERT_CLEAR,
} from '../actions/alerts';
-import Immutable from 'immutable';
+import { Map as ImmutableMap, List as ImmutableList } from 'immutable';
-const initialState = Immutable.List([]);
+const initialState = ImmutableList([]);
export default function alerts(state = initialState, action) {
switch(action.type) {
case ALERT_SHOW:
- return state.push(Immutable.Map({
+ return state.push(ImmutableMap({
key: state.size > 0 ? state.last().get('key') + 1 : 0,
title: action.title,
message: action.message,
import { STATUS_CARD_FETCH_SUCCESS } from '../actions/cards';
-import Immutable from 'immutable';
+import { Map as ImmutableMap, fromJS } from 'immutable';
-const initialState = Immutable.Map();
+const initialState = ImmutableMap();
export default function cards(state = initialState, action) {
switch(action.type) {
case STATUS_CARD_FETCH_SUCCESS:
- return state.set(action.id, Immutable.fromJS(action.card));
+ return state.set(action.id, fromJS(action.card));
default:
return state;
}
} from '../actions/compose';
import { TIMELINE_DELETE } from '../actions/timelines';
import { STORE_HYDRATE } from '../actions/store';
-import Immutable from 'immutable';
+import { Map as ImmutableMap, List as ImmutableList, OrderedSet as ImmutableOrderedSet, fromJS } from 'immutable';
import uuid from '../uuid';
-const initialState = Immutable.Map({
+const initialState = ImmutableMap({
mounted: false,
sensitive: false,
spoiler: false,
is_submitting: false,
is_uploading: false,
progress: 0,
- media_attachments: Immutable.List(),
+ media_attachments: ImmutableList(),
suggestion_token: null,
- suggestions: Immutable.List(),
+ suggestions: ImmutableList(),
me: null,
default_privacy: 'public',
default_sensitive: false,
});
function statusToTextMentions(state, status) {
- let set = Immutable.OrderedSet([]);
+ let set = ImmutableOrderedSet([]);
let me = state.get('me');
if (status.getIn(['account', 'id']) !== me) {
return state.withMutations(map => {
map.update('text', oldText => `${oldText.slice(0, position)}${completion} ${oldText.slice(position + token.length)}`);
map.set('suggestion_token', null);
- map.update('suggestions', Immutable.List(), list => list.clear());
+ map.update('suggestions', ImmutableList(), list => list.clear());
map.set('focusDate', new Date());
map.set('idempotencyKey', uuid());
});
map.set('is_uploading', true);
});
case COMPOSE_UPLOAD_SUCCESS:
- return appendMedia(state, Immutable.fromJS(action.media));
+ return appendMedia(state, fromJS(action.media));
case COMPOSE_UPLOAD_FAIL:
return state.set('is_uploading', false);
case COMPOSE_UPLOAD_UNDO:
.set('focusDate', new Date())
.set('idempotencyKey', uuid());
case COMPOSE_SUGGESTIONS_CLEAR:
- return state.update('suggestions', Immutable.List(), list => list.clear()).set('suggestion_token', null);
+ return state.update('suggestions', ImmutableList(), list => list.clear()).set('suggestion_token', null);
case COMPOSE_SUGGESTIONS_READY:
- return state.set('suggestions', Immutable.List(action.accounts.map(item => item.id))).set('suggestion_token', action.token);
+ return state.set('suggestions', ImmutableList(action.accounts.map(item => item.id))).set('suggestion_token', action.token);
case COMPOSE_SUGGESTION_SELECT:
return insertSuggestion(state, action.position, action.token, action.completion);
case TIMELINE_DELETE:
import { CONTEXT_FETCH_SUCCESS } from '../actions/statuses';
import { TIMELINE_DELETE } from '../actions/timelines';
-import Immutable from 'immutable';
+import { Map as ImmutableMap, List as ImmutableList, fromJS } from 'immutable';
-const initialState = Immutable.Map({
- ancestors: Immutable.Map(),
- descendants: Immutable.Map(),
+const initialState = ImmutableMap({
+ ancestors: ImmutableMap(),
+ descendants: ImmutableMap(),
});
const normalizeContext = (state, id, ancestors, descendants) => {
};
const deleteFromContexts = (state, id) => {
- state.getIn(['descendants', id], Immutable.List()).forEach(descendantId => {
- state = state.updateIn(['ancestors', descendantId], Immutable.List(), list => list.filterNot(itemId => itemId === id));
+ state.getIn(['descendants', id], ImmutableList()).forEach(descendantId => {
+ state = state.updateIn(['ancestors', descendantId], ImmutableList(), list => list.filterNot(itemId => itemId === id));
});
- state.getIn(['ancestors', id], Immutable.List()).forEach(ancestorId => {
- state = state.updateIn(['descendants', ancestorId], Immutable.List(), list => list.filterNot(itemId => itemId === id));
+ state.getIn(['ancestors', id], ImmutableList()).forEach(ancestorId => {
+ state = state.updateIn(['descendants', ancestorId], ImmutableList(), list => list.filterNot(itemId => itemId === id));
});
state = state.deleteIn(['descendants', id]).deleteIn(['ancestors', id]);
export default function contexts(state = initialState, action) {
switch(action.type) {
case CONTEXT_FETCH_SUCCESS:
- return normalizeContext(state, action.id, Immutable.fromJS(action.ancestors), Immutable.fromJS(action.descendants));
+ return normalizeContext(state, action.id, fromJS(action.ancestors), fromJS(action.descendants));
case TIMELINE_DELETE:
return deleteFromContexts(state, action.id);
default:
import { STORE_HYDRATE } from '../actions/store';
-import Immutable from 'immutable';
+import { Map as ImmutableMap } from 'immutable';
-const initialState = Immutable.Map({
+const initialState = ImmutableMap({
accept_content_types: [],
});
import { STORE_HYDRATE } from '../actions/store';
-import Immutable from 'immutable';
+import { Map as ImmutableMap } from 'immutable';
-const initialState = Immutable.Map({
+const initialState = ImmutableMap({
streaming_api_base_url: null,
access_token: null,
me: null,
} from '../actions/notifications';
import { ACCOUNT_BLOCK_SUCCESS } from '../actions/accounts';
import { TIMELINE_DELETE } from '../actions/timelines';
-import Immutable from 'immutable';
+import { Map as ImmutableMap, List as ImmutableList } from 'immutable';
-const initialState = Immutable.Map({
- items: Immutable.List(),
+const initialState = ImmutableMap({
+ items: ImmutableList(),
next: null,
top: true,
unread: 0,
isLoading: true,
});
-const notificationToMap = notification => Immutable.Map({
+const notificationToMap = notification => ImmutableMap({
id: notification.id,
type: notification.type,
account: notification.account.id,
};
const normalizeNotifications = (state, notifications, next) => {
- let items = Immutable.List();
+ let items = ImmutableList();
const loaded = state.get('loaded');
notifications.forEach((n, i) => {
};
const appendNormalizedNotifications = (state, notifications, next) => {
- let items = Immutable.List();
+ let items = ImmutableList();
notifications.forEach((n, i) => {
items = items.set(i, notificationToMap(n));
case ACCOUNT_BLOCK_SUCCESS:
return filterNotifications(state, action.relationship);
case NOTIFICATIONS_CLEAR:
- return state.set('items', Immutable.List()).set('next', null);
+ return state.set('items', ImmutableList()).set('next', null);
case TIMELINE_DELETE:
return deleteByStatus(state, action.id);
default:
DOMAIN_BLOCK_SUCCESS,
DOMAIN_UNBLOCK_SUCCESS,
} from '../actions/domain_blocks';
-import Immutable from 'immutable';
+import { Map as ImmutableMap, fromJS } from 'immutable';
-const normalizeRelationship = (state, relationship) => state.set(relationship.id, Immutable.fromJS(relationship));
+const normalizeRelationship = (state, relationship) => state.set(relationship.id, fromJS(relationship));
const normalizeRelationships = (state, relationships) => {
relationships.forEach(relationship => {
return state;
};
-const initialState = Immutable.Map();
+const initialState = ImmutableMap();
export default function relationships(state = initialState, action) {
switch(action.type) {
REPORT_STATUS_TOGGLE,
REPORT_COMMENT_CHANGE,
} from '../actions/reports';
-import Immutable from 'immutable';
+import { Map as ImmutableMap, Set as ImmutableSet } from 'immutable';
-const initialState = Immutable.Map({
- new: Immutable.Map({
+const initialState = ImmutableMap({
+ new: ImmutableMap({
isSubmitting: false,
account_id: null,
- status_ids: Immutable.Set(),
+ status_ids: ImmutableSet(),
comment: '',
}),
});
map.setIn(['new', 'account_id'], action.account.get('id'));
if (state.getIn(['new', 'account_id']) !== action.account.get('id')) {
- map.setIn(['new', 'status_ids'], action.status ? Immutable.Set([action.status.getIn(['reblog', 'id'], action.status.get('id'))]) : Immutable.Set());
+ map.setIn(['new', 'status_ids'], action.status ? ImmutableSet([action.status.getIn(['reblog', 'id'], action.status.get('id'))]) : ImmutableSet());
map.setIn(['new', 'comment'], '');
} else {
- map.updateIn(['new', 'status_ids'], Immutable.Set(), set => set.add(action.status.getIn(['reblog', 'id'], action.status.get('id'))));
+ map.updateIn(['new', 'status_ids'], ImmutableSet(), set => set.add(action.status.getIn(['reblog', 'id'], action.status.get('id'))));
}
});
case REPORT_STATUS_TOGGLE:
- return state.updateIn(['new', 'status_ids'], Immutable.Set(), set => {
+ return state.updateIn(['new', 'status_ids'], ImmutableSet(), set => {
if (action.checked) {
return set.add(action.statusId);
}
case REPORT_SUBMIT_SUCCESS:
return state.withMutations(map => {
map.setIn(['new', 'account_id'], null);
- map.setIn(['new', 'status_ids'], Immutable.Set());
+ map.setIn(['new', 'status_ids'], ImmutableSet());
map.setIn(['new', 'comment'], '');
map.setIn(['new', 'isSubmitting'], false);
});
SEARCH_SHOW,
} from '../actions/search';
import { COMPOSE_MENTION, COMPOSE_REPLY } from '../actions/compose';
-import Immutable from 'immutable';
+import { Map as ImmutableMap, List as ImmutableList } from 'immutable';
-const initialState = Immutable.Map({
+const initialState = ImmutableMap({
value: '',
submitted: false,
hidden: false,
- results: Immutable.Map(),
+ results: ImmutableMap(),
});
export default function search(state = initialState, action) {
case SEARCH_CLEAR:
return state.withMutations(map => {
map.set('value', '');
- map.set('results', Immutable.Map());
+ map.set('results', ImmutableMap());
map.set('submitted', false);
map.set('hidden', false);
});
case COMPOSE_MENTION:
return state.set('hidden', true);
case SEARCH_FETCH_SUCCESS:
- return state.set('results', Immutable.Map({
- accounts: Immutable.List(action.results.accounts.map(item => item.id)),
- statuses: Immutable.List(action.results.statuses.map(item => item.id)),
- hashtags: Immutable.List(action.results.hashtags),
+ return state.set('results', ImmutableMap({
+ accounts: ImmutableList(action.results.accounts.map(item => item.id)),
+ statuses: ImmutableList(action.results.statuses.map(item => item.id)),
+ hashtags: ImmutableList(action.results.hashtags),
})).set('submitted', true);
default:
return state;
import { SETTING_CHANGE } from '../actions/settings';
import { COLUMN_ADD, COLUMN_REMOVE, COLUMN_MOVE } from '../actions/columns';
import { STORE_HYDRATE } from '../actions/store';
-import Immutable from 'immutable';
+import { Map as ImmutableMap, fromJS } from 'immutable';
import uuid from '../uuid';
-const initialState = Immutable.Map({
+const initialState = ImmutableMap({
onboarded: false,
- home: Immutable.Map({
- shows: Immutable.Map({
+ home: ImmutableMap({
+ shows: ImmutableMap({
reblog: true,
reply: true,
}),
- regex: Immutable.Map({
+ regex: ImmutableMap({
body: '',
}),
}),
- notifications: Immutable.Map({
- alerts: Immutable.Map({
+ notifications: ImmutableMap({
+ alerts: ImmutableMap({
follow: true,
favourite: true,
reblog: true,
mention: true,
}),
- shows: Immutable.Map({
+ shows: ImmutableMap({
follow: true,
favourite: true,
reblog: true,
mention: true,
}),
- sounds: Immutable.Map({
+ sounds: ImmutableMap({
follow: true,
favourite: true,
reblog: true,
}),
}),
- community: Immutable.Map({
- regex: Immutable.Map({
+ community: ImmutableMap({
+ regex: ImmutableMap({
body: '',
}),
}),
- public: Immutable.Map({
- regex: Immutable.Map({
+ public: ImmutableMap({
+ regex: ImmutableMap({
body: '',
}),
}),
});
-const defaultColumns = Immutable.fromJS([
+const defaultColumns = fromJS([
{ id: 'COMPOSE', uuid: uuid(), params: {} },
{ id: 'HOME', uuid: uuid(), params: {} },
{ id: 'NOTIFICATIONS', uuid: uuid(), params: {} },
case SETTING_CHANGE:
return state.setIn(action.key, action.value);
case COLUMN_ADD:
- return state.update('columns', list => list.push(Immutable.fromJS({ id: action.id, uuid: uuid(), params: action.params })));
+ return state.update('columns', list => list.push(fromJS({ id: action.id, uuid: uuid(), params: action.params })));
case COLUMN_REMOVE:
return state.update('columns', list => list.filterNot(item => item.get('uuid') === action.uuid));
case COLUMN_MOVE:
FAVOURITED_STATUSES_FETCH_SUCCESS,
FAVOURITED_STATUSES_EXPAND_SUCCESS,
} from '../actions/favourites';
-import Immutable from 'immutable';
+import { Map as ImmutableMap, List as ImmutableList } from 'immutable';
-const initialState = Immutable.Map({
- favourites: Immutable.Map({
+const initialState = ImmutableMap({
+ favourites: ImmutableMap({
next: null,
loaded: false,
- items: Immutable.List(),
+ items: ImmutableList(),
}),
});
return state.update(listType, listMap => listMap.withMutations(map => {
map.set('next', next);
map.set('loaded', true);
- map.set('items', Immutable.List(statuses.map(item => item.id)));
+ map.set('items', ImmutableList(statuses.map(item => item.id)));
}));
};
FAVOURITED_STATUSES_EXPAND_SUCCESS,
} from '../actions/favourites';
import { SEARCH_FETCH_SUCCESS } from '../actions/search';
-import Immutable from 'immutable';
+import { Map as ImmutableMap, fromJS } from 'immutable';
const normalizeStatus = (state, status) => {
if (!status) {
const searchContent = [status.spoiler_text, status.content].join(' ').replace(/<br \/>/g, '\n').replace(/<\/p><p>/g, '\n\n');
normalStatus.search_index = new DOMParser().parseFromString(searchContent, 'text/html').documentElement.textContent;
- return state.update(status.id, Immutable.Map(), map => map.mergeDeep(Immutable.fromJS(normalStatus)));
+ return state.update(status.id, ImmutableMap(), map => map.mergeDeep(fromJS(normalStatus)));
};
const normalizeStatuses = (state, statuses) => {
return state;
};
-const initialState = Immutable.Map();
+const initialState = ImmutableMap();
export default function statuses(state = initialState, action) {
switch(action.type) {
ACCOUNT_BLOCK_SUCCESS,
ACCOUNT_MUTE_SUCCESS,
} from '../actions/accounts';
-import Immutable from 'immutable';
+import { Map as ImmutableMap, List as ImmutableList, fromJS } from 'immutable';
-const initialState = Immutable.Map();
+const initialState = ImmutableMap();
-const initialTimeline = Immutable.Map({
+const initialTimeline = ImmutableMap({
unread: 0,
online: false,
top: true,
loaded: false,
isLoading: false,
next: false,
- items: Immutable.List(),
+ items: ImmutableList(),
});
const normalizeTimeline = (state, timeline, statuses, next) => {
- const ids = Immutable.List(statuses.map(status => status.get('id')));
+ const ids = ImmutableList(statuses.map(status => status.get('id')));
const wasLoaded = state.getIn([timeline, 'loaded']);
const hadNext = state.getIn([timeline, 'next']);
- const oldIds = state.getIn([timeline, 'items'], Immutable.List());
+ const oldIds = state.getIn([timeline, 'items'], ImmutableList());
return state.update(timeline, initialTimeline, map => map.withMutations(mMap => {
mMap.set('loaded', true);
};
const appendNormalizedTimeline = (state, timeline, statuses, next) => {
- const ids = Immutable.List(statuses.map(status => status.get('id')));
- const oldIds = state.getIn([timeline, 'items'], Immutable.List());
+ const ids = ImmutableList(statuses.map(status => status.get('id')));
+ const oldIds = state.getIn([timeline, 'items'], ImmutableList());
return state.update(timeline, initialTimeline, map => map.withMutations(mMap => {
mMap.set('isLoading', false);
const updateTimeline = (state, timeline, status, references) => {
const top = state.getIn([timeline, 'top']);
- const ids = state.getIn([timeline, 'items'], Immutable.List());
+ const ids = state.getIn([timeline, 'items'], ImmutableList());
const includesId = ids.includes(status.get('id'));
const unread = state.getIn([timeline, 'unread'], 0);
case TIMELINE_EXPAND_FAIL:
return state.update(action.timeline, initialTimeline, map => map.set('isLoading', false));
case TIMELINE_REFRESH_SUCCESS:
- return normalizeTimeline(state, action.timeline, Immutable.fromJS(action.statuses), action.next);
+ return normalizeTimeline(state, action.timeline, fromJS(action.statuses), action.next);
case TIMELINE_EXPAND_SUCCESS:
- return appendNormalizedTimeline(state, action.timeline, Immutable.fromJS(action.statuses), action.next);
+ return appendNormalizedTimeline(state, action.timeline, fromJS(action.statuses), action.next);
case TIMELINE_UPDATE:
- return updateTimeline(state, action.timeline, Immutable.fromJS(action.status), action.references);
+ return updateTimeline(state, action.timeline, fromJS(action.status), action.references);
case TIMELINE_DELETE:
return deleteStatus(state, action.id, action.accountId, action.references, action.reblogOf);
case ACCOUNT_BLOCK_SUCCESS:
MUTES_FETCH_SUCCESS,
MUTES_EXPAND_SUCCESS,
} from '../actions/mutes';
-import Immutable from 'immutable';
+import { Map as ImmutableMap, List as ImmutableList } from 'immutable';
-const initialState = Immutable.Map({
- followers: Immutable.Map(),
- following: Immutable.Map(),
- reblogged_by: Immutable.Map(),
- favourited_by: Immutable.Map(),
- follow_requests: Immutable.Map(),
- blocks: Immutable.Map(),
- mutes: Immutable.Map(),
+const initialState = ImmutableMap({
+ followers: ImmutableMap(),
+ following: ImmutableMap(),
+ reblogged_by: ImmutableMap(),
+ favourited_by: ImmutableMap(),
+ follow_requests: ImmutableMap(),
+ blocks: ImmutableMap(),
+ mutes: ImmutableMap(),
});
const normalizeList = (state, type, id, accounts, next) => {
- return state.setIn([type, id], Immutable.Map({
+ return state.setIn([type, id], ImmutableMap({
next,
- items: Immutable.List(accounts.map(item => item.id)),
+ items: ImmutableList(accounts.map(item => item.id)),
}));
};
case FOLLOWING_EXPAND_SUCCESS:
return appendToList(state, 'following', action.id, action.accounts, action.next);
case REBLOGS_FETCH_SUCCESS:
- return state.setIn(['reblogged_by', action.id], Immutable.List(action.accounts.map(item => item.id)));
+ return state.setIn(['reblogged_by', action.id], ImmutableList(action.accounts.map(item => item.id)));
case FAVOURITES_FETCH_SUCCESS:
- return state.setIn(['favourited_by', action.id], Immutable.List(action.accounts.map(item => item.id)));
+ return state.setIn(['favourited_by', action.id], ImmutableList(action.accounts.map(item => item.id)));
case FOLLOW_REQUESTS_FETCH_SUCCESS:
- return state.setIn(['follow_requests', 'items'], Immutable.List(action.accounts.map(item => item.id))).setIn(['follow_requests', 'next'], action.next);
+ return state.setIn(['follow_requests', 'items'], ImmutableList(action.accounts.map(item => item.id))).setIn(['follow_requests', 'next'], action.next);
case FOLLOW_REQUESTS_EXPAND_SUCCESS:
return state.updateIn(['follow_requests', 'items'], list => list.concat(action.accounts.map(item => item.id))).setIn(['follow_requests', 'next'], action.next);
case FOLLOW_REQUEST_AUTHORIZE_SUCCESS:
case FOLLOW_REQUEST_REJECT_SUCCESS:
return state.updateIn(['follow_requests', 'items'], list => list.filterNot(item => item === action.id));
case BLOCKS_FETCH_SUCCESS:
- return state.setIn(['blocks', 'items'], Immutable.List(action.accounts.map(item => item.id))).setIn(['blocks', 'next'], action.next);
+ return state.setIn(['blocks', 'items'], ImmutableList(action.accounts.map(item => item.id))).setIn(['blocks', 'next'], action.next);
case BLOCKS_EXPAND_SUCCESS:
return state.updateIn(['blocks', 'items'], list => list.concat(action.accounts.map(item => item.id))).setIn(['blocks', 'next'], action.next);
case MUTES_FETCH_SUCCESS:
- return state.setIn(['mutes', 'items'], Immutable.List(action.accounts.map(item => item.id))).setIn(['mutes', 'next'], action.next);
+ return state.setIn(['mutes', 'items'], ImmutableList(action.accounts.map(item => item.id))).setIn(['mutes', 'next'], action.next);
case MUTES_EXPAND_SUCCESS:
return state.updateIn(['mutes', 'items'], list => list.concat(action.accounts.map(item => item.id))).setIn(['mutes', 'next'], action.next);
default:
import { createSelector } from 'reselect';
-import Immutable from 'immutable';
+import { List as ImmutableList } from 'immutable';
const getAccountBase = (state, id) => state.getIn(['accounts', id], null);
const getAccountCounters = (state, id) => state.getIn(['accounts_counters', id], null);
};
export const getAccountGallery = createSelector([
- (state, id) => state.getIn(['timelines', `account:${id}:media`, 'items'], Immutable.List()),
+ (state, id) => state.getIn(['timelines', `account:${id}:media`, 'items'], ImmutableList()),
state => state.get('statuses'),
], (statusIds, statuses) => {
- let medias = Immutable.List();
+ let medias = ImmutableList();
statusIds.forEach(statusId => {
const status = statuses.get(statusId);
import { expect } from 'chai';
import { render } from 'enzyme';
-import Immutable from 'immutable';
+import { fromJS } from 'immutable';
import React from 'react';
import DisplayName from '../../../app/javascript/mastodon/components/display_name';
describe('<DisplayName />', () => {
it('renders display name + account name', () => {
- const account = Immutable.fromJS({
+ const account = fromJS({
username: 'bar',
acct: 'bar@baz',
display_name: 'Foo',
});
it('renders the username + account name if display name is empty', () => {
- const account = Immutable.fromJS({
+ const account = fromJS({
username: 'bar',
acct: 'bar@baz',
display_name: '',
cat aescling's git repositories / mastodon.git / commitdiff