gitea/nas
1
0
Fork 2
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions 1

Merge remote-tracking branch 'parent/main' into upstream-2024112

Browse source
This commit is contained in:
KMY 2024-11-28 19:45:31 +09:00
commit 3359008684
71 changed files with 1505 additions and 2295 deletions
Download patch file Download diff file Expand all files Collapse all files

53
app/javascript/mastodon/reducers/bookmark_category_adder.js
View file

@ -1,53 +0,0 @@
import { Map as ImmutableMap, List as ImmutableList } from 'immutable';
import {
BOOKMARK_CATEGORY_ADDER_RESET,
BOOKMARK_CATEGORY_ADDER_SETUP,
BOOKMARK_CATEGORY_ADDER_BOOKMARK_CATEGORIES_FETCH_REQUEST,
BOOKMARK_CATEGORY_ADDER_BOOKMARK_CATEGORIES_FETCH_SUCCESS,
BOOKMARK_CATEGORY_ADDER_BOOKMARK_CATEGORIES_FETCH_FAIL,
BOOKMARK_CATEGORY_EDITOR_ADD_SUCCESS,
BOOKMARK_CATEGORY_EDITOR_REMOVE_SUCCESS,
} from '../actions/bookmark_categories';
import {
UNBOOKMARK_SUCCESS,
} from '../actions/interactions';
const initialState = ImmutableMap({
statusId: null,
bookmarkCategories: ImmutableMap({
items: ImmutableList(),
loaded: false,
isLoading: false,
}),
});
export default function bookmarkCategoryAdderReducer(state = initialState, action) {
switch(action.type) {
case BOOKMARK_CATEGORY_ADDER_RESET:
return initialState;
case BOOKMARK_CATEGORY_ADDER_SETUP:
return state.withMutations(map => {
map.set('statusId', action.status.get('id'));
});
case BOOKMARK_CATEGORY_ADDER_BOOKMARK_CATEGORIES_FETCH_REQUEST:
return state.setIn(['bookmarkCategories', 'isLoading'], true);
case BOOKMARK_CATEGORY_ADDER_BOOKMARK_CATEGORIES_FETCH_FAIL:
return state.setIn(['bookmarkCategories', 'isLoading'], false);
case BOOKMARK_CATEGORY_ADDER_BOOKMARK_CATEGORIES_FETCH_SUCCESS:
return state.update('bookmarkCategories', bookmarkCategories => bookmarkCategories.withMutations(map => {
map.set('isLoading', false);
map.set('loaded', true);
map.set('items', ImmutableList(action.bookmarkCategories.map(item => item.id)));
}));
case BOOKMARK_CATEGORY_EDITOR_ADD_SUCCESS:
return state.updateIn(['bookmarkCategories', 'items'], bookmarkCategory => bookmarkCategory.unshift(action.bookmarkCategoryId));
case BOOKMARK_CATEGORY_EDITOR_REMOVE_SUCCESS:
return state.updateIn(['bookmarkCategories', 'items'], bookmarkCategory => bookmarkCategory.filterNot(item => item === action.bookmarkCategoryId));
case UNBOOKMARK_SUCCESS:
return action.status.get('id') === state.get('statusId') ? state.setIn(['bookmarkCategories', 'items'], ImmutableList()) : state;
default:
return state;
}
}

67
app/javascript/mastodon/reducers/bookmark_category_editor.js
View file

@ -1,67 +0,0 @@
import { Map as ImmutableMap, List as ImmutableList } from 'immutable';
import {
BOOKMARK_CATEGORY_CREATE_REQUEST,
BOOKMARK_CATEGORY_CREATE_FAIL,
BOOKMARK_CATEGORY_CREATE_SUCCESS,
BOOKMARK_CATEGORY_UPDATE_REQUEST,
BOOKMARK_CATEGORY_UPDATE_FAIL,
BOOKMARK_CATEGORY_UPDATE_SUCCESS,
BOOKMARK_CATEGORY_EDITOR_RESET,
BOOKMARK_CATEGORY_EDITOR_SETUP,
BOOKMARK_CATEGORY_EDITOR_TITLE_CHANGE,
} from '../actions/bookmark_categories';
const initialState = ImmutableMap({
bookmarkCategoryId: null,
isSubmitting: false,
isChanged: false,
title: '',
isExclusive: false,
statuses: ImmutableMap({
items: ImmutableList(),
loaded: false,
isLoading: false,
}),
suggestions: ImmutableMap({
value: '',
items: ImmutableList(),
}),
});
export default function bookmarkCategoryEditorReducer(state = initialState, action) {
switch(action.type) {
case BOOKMARK_CATEGORY_EDITOR_RESET:
return initialState;
case BOOKMARK_CATEGORY_EDITOR_SETUP:
return state.withMutations(map => {
map.set('bookmarkCategoryId', action.bookmarkCategory.get('id'));
map.set('title', action.bookmarkCategory.get('title'));
map.set('isSubmitting', false);
});
case BOOKMARK_CATEGORY_EDITOR_TITLE_CHANGE:
return state.withMutations(map => {
map.set('title', action.value);
map.set('isChanged', true);
});
case BOOKMARK_CATEGORY_CREATE_REQUEST:
case BOOKMARK_CATEGORY_UPDATE_REQUEST:
return state.withMutations(map => {
map.set('isSubmitting', true);
map.set('isChanged', false);
});
case BOOKMARK_CATEGORY_CREATE_FAIL:
case BOOKMARK_CATEGORY_UPDATE_FAIL:
return state.set('isSubmitting', false);
case BOOKMARK_CATEGORY_CREATE_SUCCESS:
case BOOKMARK_CATEGORY_UPDATE_SUCCESS:
return state.withMutations(map => {
map.set('isSubmitting', false);
map.set('bookmarkCategoryId', action.bookmarkCategory.id);
});
default:
return state;
}
}

4
app/javascript/mastodon/reducers/index.ts
View file

@ -39,7 +39,7 @@ import server from './server';
import settings from './settings';
import status_lists from './status_lists';
import statuses from './statuses';
import suggestions from './suggestions';
import { suggestionsReducer } from './suggestions';
import tags from './tags';
import timelines from './timelines';
import trends from './trends';
@ -77,7 +77,7 @@ const reducers = {
bookmark_categories: bookmarkCategoriesReducer,
filters,
conversations,
suggestions,
suggestions: suggestionsReducer,
polls,
trends,
markers: markersReducer,

96
app/javascript/mastodon/reducers/status_lists.js
View file

@ -1,12 +1,13 @@
import { Map as ImmutableMap, OrderedSet as ImmutableOrderedSet } from 'immutable';
import { BOOKMARK_CATEGORY_STATUSES_FETCH_SUCCESS, BOOKMARK_CATEGORY_STATUSES_EXPAND_SUCCESS, BOOKMARK_CATEGORY_EDITOR_ADD_SUCCESS, BOOKMARK_CATEGORY_EDITOR_REMOVE_SUCCESS } from 'mastodon/actions/bookmark_categories';
import { CIRCLE_STATUSES_EXPAND_SUCCESS, CIRCLE_STATUSES_FETCH_SUCCESS } from 'mastodon/actions/circles';
import { COMPOSE_WITH_CIRCLE_SUCCESS } from 'mastodon/actions/compose';
import {
blockAccountSuccess,
muteAccountSuccess,
} from '../actions/accounts';
import {
BOOKMARK_CATEGORY_EDITOR_ADD_SUCCESS,
} from '../actions/bookmark_categories';
import {
BOOKMARKED_STATUSES_FETCH_REQUEST,
BOOKMARKED_STATUSES_FETCH_SUCCESS,
@ -54,7 +55,6 @@ import {
} from '../actions/trends';
const initialState = ImmutableMap({
favourites: ImmutableMap({
next: null,
@ -81,9 +81,31 @@ const initialState = ImmutableMap({
loaded: false,
items: ImmutableOrderedSet(),
}),
circle_statuses: ImmutableMap(),
bookmark_category_statuses: ImmutableMap(),
});
const normalizeList = (state, listType, statuses, next) => {
if (Array.isArray(listType)) {
if (state.getIn(listType)) {
return state.updateIn(listType, listMap => {
return listMap.withMutations(map => {
map.set('next', next);
map.set('loaded', true);
map.set('isLoading', false);
map.set('items', ImmutableOrderedSet(statuses.map(item => item.id)));
});
});
} else {
return state.setIn(listType, ImmutableMap({
next: next,
loaded: true,
isLoading: false,
items: ImmutableOrderedSet(statuses.map(item => item.id)),
}));
}
}
return state.update(listType, listMap => listMap.withMutations(map => {
map.set('next', next);
map.set('loaded', true);
@ -93,6 +115,14 @@ const normalizeList = (state, listType, statuses, next) => {
};
const appendToList = (state, listType, statuses, next) => {
if (Array.isArray(listType)) {
return state.updateIn(listType, listMap => listMap.withMutations(map => {
map.set('next', next);
map.set('isLoading', false);
map.set('items', map.get('items').union(statuses.map(item => item.id)));
}));
}
return state.update(listType, listMap => listMap.withMutations(map => {
map.set('next', next);
map.set('isLoading', false);
@ -105,6 +135,16 @@ const prependOneToList = (state, listType, status) => {
};
const prependOneToListById = (state, listType, statusId) => {
if (Array.isArray(listType)) {
if (!state.getIn(listType)) return state;
return state.updateIn(listType, item => item.withMutations(map => {
if (map.get('items')) {
map.update('items', list => ImmutableOrderedSet([statusId]).union(list));
}
}));
}
return state.updateIn([listType, 'items'], (list) => {
if (list.includes(statusId)) {
return list;
@ -118,6 +158,32 @@ const removeOneFromList = (state, listType, status) => {
return state.updateIn([listType, 'items'], (list) => list.delete(status.get('id')));
};
const removeOneFromListById = (state, listType, statusId) => {
if (Array.isArray(listType)) {
if (!state.getIn(listType)) return state;
return state.updateIn(listType, item => item.withMutations(map => {
if (map.get('items')) {
map.update('items', list => list.delete(statusId));
}
}));
}
return state.update(listType, item => item.withMutations(map => {
if (map.get('items')) {
map.update('items', list => list.delete(statusId));
}
}));
};
const removeOneFromAllBookmarkCategoriesById = (state, statusId) => {
let s = state;
state.get('bookmark_category_statuses').forEach((category) => {
s = s.updateIn(['bookmark_category_statuses', category.get('id'), 'items'], list => list?.delete(statusId));
});
return s;
};
export default function statusLists(state = initialState, action) {
switch(action.type) {
case FAVOURITED_STATUSES_FETCH_REQUEST:
@ -140,6 +206,16 @@ export default function statusLists(state = initialState, action) {
return normalizeList(state, 'emoji_reactions', action.statuses, action.next);
case EMOJI_REACTED_STATUSES_EXPAND_SUCCESS:
return appendToList(state, 'emoji_reactions', action.statuses, action.next);
case CIRCLE_STATUSES_FETCH_SUCCESS:
return normalizeList(state, ['circle_statuses', action.id], action.statuses, action.next);
case CIRCLE_STATUSES_EXPAND_SUCCESS:
return appendToList(state, ['circle_statuses', action.id], action.statuses, action.next);
case COMPOSE_WITH_CIRCLE_SUCCESS:
return prependOneToListById(state, ['circle_statuses', action.circleId], action.statusId);
case BOOKMARK_CATEGORY_STATUSES_FETCH_SUCCESS:
return normalizeList(state, ['bookmark_category_statuses', action.id], action.statuses, action.next);
case BOOKMARK_CATEGORY_STATUSES_EXPAND_SUCCESS:
return appendToList(state, ['bookmark_category_statuses', action.id], action.statuses, action.next);
case BOOKMARKED_STATUSES_FETCH_REQUEST:
case BOOKMARKED_STATUSES_EXPAND_REQUEST:
return state.setIn(['bookmarks', 'isLoading'], true);
@ -171,9 +247,17 @@ export default function statusLists(state = initialState, action) {
case BOOKMARK_SUCCESS:
return prependOneToList(state, 'bookmarks', action.status);
case BOOKMARK_CATEGORY_EDITOR_ADD_SUCCESS:
return prependOneToListById(state, 'bookmarks', action.statusId);
{
const s = prependOneToListById(state, 'bookmarks', action.statusId);
return prependOneToListById(s, ['bookmark_category_statuses', action.id], action.statusId);
}
case BOOKMARK_CATEGORY_EDITOR_REMOVE_SUCCESS:
return removeOneFromListById(state, ['bookmark_category_statuses', action.id], action.statusId);
case UNBOOKMARK_SUCCESS:
return removeOneFromList(state, 'bookmarks', action.status);
{
const s = removeOneFromList(state, 'bookmarks', action.status);
return removeOneFromAllBookmarkCategoriesById(s, action.statusId);
}
case PINNED_STATUSES_FETCH_SUCCESS:
return normalizeList(state, 'pins', action.statuses, action.next);
case PIN_SUCCESS:

7
app/javascript/mastodon/reducers/statuses.js
View file

@ -4,8 +4,7 @@ import { timelineDelete } from 'mastodon/actions/timelines_typed';
import { me } from 'mastodon/initial_state';
import {
BOOKMARK_CATEGORY_EDITOR_ADD_REQUEST,
BOOKMARK_CATEGORY_EDITOR_ADD_FAIL,
BOOKMARK_CATEGORY_EDITOR_ADD_SUCCESS,
} from '../actions/bookmark_categories';
import { STATUS_IMPORT, STATUSES_IMPORT } from '../actions/importer';
import { normalizeStatusTranslation } from '../actions/importer/normalizer';
@ -122,10 +121,8 @@ export default function statuses(state = initialState, action) {
return state.get(action.status.get('id')) === undefined ? state : state.setIn([action.status.get('id'), 'bookmarked'], true);
case BOOKMARK_FAIL:
return state.get(action.status.get('id')) === undefined ? state : state.setIn([action.status.get('id'), 'bookmarked'], false);
case BOOKMARK_CATEGORY_EDITOR_ADD_REQUEST:
case BOOKMARK_CATEGORY_EDITOR_ADD_SUCCESS:
return state.get(action.statusId) === undefined ? state : state.setIn([action.statusId, 'bookmarked'], true);
case BOOKMARK_CATEGORY_EDITOR_ADD_FAIL:
return state.get(action.statusId) === undefined ? state : state.setIn([action.statusId, 'bookmarked'], false);
case UNBOOKMARK_REQUEST:
return state.get(action.status.get('id')) === undefined ? state : state.setIn([action.status.get('id'), 'bookmarked'], false);
case UNBOOKMARK_FAIL:

40
app/javascript/mastodon/reducers/suggestions.js
View file

@ -1,40 +0,0 @@
import { Map as ImmutableMap, List as ImmutableList, fromJS } from 'immutable';
import { blockAccountSuccess, muteAccountSuccess } from 'mastodon/actions/accounts';
import { blockDomainSuccess } from 'mastodon/actions/domain_blocks';
import {
SUGGESTIONS_FETCH_REQUEST,
SUGGESTIONS_FETCH_SUCCESS,
SUGGESTIONS_FETCH_FAIL,
SUGGESTIONS_DISMISS,
} from '../actions/suggestions';
const initialState = ImmutableMap({
items: ImmutableList(),
isLoading: false,
});
export default function suggestionsReducer(state = initialState, action) {
switch(action.type) {
case SUGGESTIONS_FETCH_REQUEST:
return state.set('isLoading', true);
case SUGGESTIONS_FETCH_SUCCESS:
return state.withMutations(map => {
map.set('items', fromJS(action.suggestions.map(x => ({ ...x, account: x.account.id }))));
map.set('isLoading', false);
});
case SUGGESTIONS_FETCH_FAIL:
return state.set('isLoading', false);
case SUGGESTIONS_DISMISS:
return state.update('items', list => list.filterNot(x => x.get('account') === action.id));
case blockAccountSuccess.type:
case muteAccountSuccess.type:
return state.update('items', list => list.filterNot(x => x.get('account') === action.payload.relationship.id));
case blockDomainSuccess.type:
return state.update('items', list => list.filterNot(x => action.payload.accounts.includes(x.get('account'))));
default:
return state;
}
}

60
app/javascript/mastodon/reducers/suggestions.ts Normal file
View file

@ -0,0 +1,60 @@
import { createReducer, isAnyOf } from '@reduxjs/toolkit';
import {
blockAccountSuccess,
muteAccountSuccess,
} from 'mastodon/actions/accounts';
import { blockDomainSuccess } from 'mastodon/actions/domain_blocks';
import {
fetchSuggestions,
dismissSuggestion,
} from 'mastodon/actions/suggestions';
import { createSuggestion } from 'mastodon/models/suggestion';
import type { Suggestion } from 'mastodon/models/suggestion';
interface State {
items: Suggestion[];
isLoading: boolean;
}
const initialState: State = {
items: [],
isLoading: false,
};
export const suggestionsReducer = createReducer(initialState, (builder) => {
builder.addCase(fetchSuggestions.pending, (state) => {
state.isLoading = true;
});
builder.addCase(fetchSuggestions.fulfilled, (state, action) => {
state.items = action.payload.map(createSuggestion);
state.isLoading = false;
});
builder.addCase(fetchSuggestions.rejected, (state) => {
state.isLoading = false;
});
builder.addCase(dismissSuggestion.pending, (state, action) => {
state.items = state.items.filter(
(x) => x.account_id !== action.meta.arg.accountId,
);
});
builder.addCase(blockDomainSuccess, (state, action) => {
state.items = state.items.filter(
(x) =>
!action.payload.accounts.some((account) => account.id === x.account_id),
);
});
builder.addMatcher(
isAnyOf(blockAccountSuccess, muteAccountSuccess),
(state, action) => {
state.items = state.items.filter(
(x) => x.account_id !== action.payload.relationship.id,
);
},
);
});