748 lines
28 KiB
TypeScript
748 lines
28 KiB
TypeScript
import { create } from 'mutative';
|
|
|
|
import { INSTANCE_FETCH_SUCCESS, type InstanceAction } from 'pl-fe/actions/instance';
|
|
import { tagHistory } from 'pl-fe/settings';
|
|
|
|
import {
|
|
COMPOSE_CHANGE,
|
|
COMPOSE_REPLY,
|
|
COMPOSE_REPLY_CANCEL,
|
|
COMPOSE_QUOTE,
|
|
COMPOSE_QUOTE_CANCEL,
|
|
COMPOSE_GROUP_POST,
|
|
COMPOSE_DIRECT,
|
|
COMPOSE_MENTION,
|
|
COMPOSE_SUBMIT_REQUEST,
|
|
COMPOSE_SUBMIT_SUCCESS,
|
|
COMPOSE_SUBMIT_FAIL,
|
|
COMPOSE_UPLOAD_REQUEST,
|
|
COMPOSE_UPLOAD_SUCCESS,
|
|
COMPOSE_UPLOAD_FAIL,
|
|
COMPOSE_UPLOAD_UNDO,
|
|
COMPOSE_UPLOAD_PROGRESS,
|
|
COMPOSE_SUGGESTIONS_CLEAR,
|
|
COMPOSE_SUGGESTIONS_READY,
|
|
COMPOSE_SUGGESTION_SELECT,
|
|
COMPOSE_SUGGESTION_TAGS_UPDATE,
|
|
COMPOSE_TAG_HISTORY_UPDATE,
|
|
COMPOSE_SPOILERNESS_CHANGE,
|
|
COMPOSE_TYPE_CHANGE,
|
|
COMPOSE_SPOILER_TEXT_CHANGE,
|
|
COMPOSE_VISIBILITY_CHANGE,
|
|
COMPOSE_LANGUAGE_CHANGE,
|
|
COMPOSE_MODIFIED_LANGUAGE_CHANGE,
|
|
COMPOSE_LANGUAGE_ADD,
|
|
COMPOSE_LANGUAGE_DELETE,
|
|
COMPOSE_ADD_SUGGESTED_LANGUAGE,
|
|
COMPOSE_UPLOAD_CHANGE_REQUEST,
|
|
COMPOSE_UPLOAD_CHANGE_SUCCESS,
|
|
COMPOSE_UPLOAD_CHANGE_FAIL,
|
|
COMPOSE_RESET,
|
|
COMPOSE_POLL_ADD,
|
|
COMPOSE_POLL_REMOVE,
|
|
COMPOSE_SCHEDULE_ADD,
|
|
COMPOSE_SCHEDULE_SET,
|
|
COMPOSE_SCHEDULE_REMOVE,
|
|
COMPOSE_POLL_OPTION_ADD,
|
|
COMPOSE_POLL_OPTION_CHANGE,
|
|
COMPOSE_POLL_OPTION_REMOVE,
|
|
COMPOSE_POLL_SETTINGS_CHANGE,
|
|
COMPOSE_ADD_TO_MENTIONS,
|
|
COMPOSE_REMOVE_FROM_MENTIONS,
|
|
COMPOSE_SET_STATUS,
|
|
COMPOSE_EVENT_REPLY,
|
|
COMPOSE_EDITOR_STATE_SET,
|
|
COMPOSE_CHANGE_MEDIA_ORDER,
|
|
COMPOSE_ADD_SUGGESTED_QUOTE,
|
|
COMPOSE_FEDERATED_CHANGE,
|
|
COMPOSE_INTERACTION_POLICY_OPTION_CHANGE,
|
|
COMPOSE_CLEAR_LINK_SUGGESTION_CREATE,
|
|
COMPOSE_CLEAR_LINK_SUGGESTION_IGNORE,
|
|
COMPOSE_PREVIEW_SUCCESS,
|
|
COMPOSE_PREVIEW_CANCEL,
|
|
type ComposeAction,
|
|
type ComposeSuggestionSelectAction,
|
|
} from '../actions/compose';
|
|
import { EVENT_COMPOSE_CANCEL, EVENT_FORM_SET, type EventsAction } from '../actions/events';
|
|
import { ME_FETCH_SUCCESS, ME_PATCH_SUCCESS, type MeAction } from '../actions/me';
|
|
import { FE_NAME } from '../actions/settings';
|
|
import { TIMELINE_DELETE, type TimelineAction } from '../actions/timelines';
|
|
import { unescapeHTML } from '../utils/html';
|
|
|
|
import type { CredentialAccount, Instance, InteractionPolicy, MediaAttachment, Status as BaseStatus, Tag } from 'pl-api';
|
|
import type { Emoji } from 'pl-fe/features/emoji';
|
|
import type { Language } from 'pl-fe/features/preferences';
|
|
import type { Account } from 'pl-fe/normalizers/account';
|
|
import type { Status } from 'pl-fe/normalizers/status';
|
|
|
|
const getResetFileKey = () => Math.floor((Math.random() * 0x10000));
|
|
|
|
interface ComposePoll {
|
|
options: Array<string>;
|
|
options_map: Array<Record<Language | string, string>>;
|
|
expires_in: number;
|
|
multiple: boolean;
|
|
hide_totals: boolean;
|
|
}
|
|
|
|
const newPoll = (params: Partial<ComposePoll> = {}): ComposePoll => ({
|
|
options: ['', ''],
|
|
options_map: [{}, {}],
|
|
expires_in: 24 * 3600,
|
|
multiple: false,
|
|
hide_totals: false,
|
|
...params,
|
|
});
|
|
|
|
interface ClearLinkSuggestion {
|
|
key: string;
|
|
originalUrl: string;
|
|
cleanUrl: string;
|
|
}
|
|
|
|
interface Compose {
|
|
caretPosition: number | null;
|
|
content_type: string;
|
|
draft_id: string | null;
|
|
editorState: string | null;
|
|
editorStateMap: Record<Language | string, string | null>;
|
|
focusDate: Date | null;
|
|
group_id: string | null;
|
|
idempotencyKey: string;
|
|
id: string | null;
|
|
in_reply_to: string | null;
|
|
is_changing_upload: boolean;
|
|
is_composing: boolean;
|
|
is_submitting: boolean;
|
|
is_uploading: boolean;
|
|
media_attachments: Array<MediaAttachment>;
|
|
poll: ComposePoll | null;
|
|
privacy: string;
|
|
progress: number;
|
|
quote: string | null;
|
|
resetFileKey: number | null;
|
|
schedule: Date | null;
|
|
sensitive: boolean;
|
|
spoiler_text: string;
|
|
spoilerTextMap: Record<Language | string, string>;
|
|
suggestions: Array<string> | Array<Emoji>;
|
|
suggestion_token: string | null;
|
|
tagHistory: Array<string>;
|
|
text: string;
|
|
textMap: Record<Language | string, string>;
|
|
to: Array<string>;
|
|
parent_reblogged_by: string | null;
|
|
dismissed_quotes: Array<string>;
|
|
language: Language | string | null;
|
|
modified_language: Language | string | null;
|
|
suggested_language: string | null;
|
|
federated: boolean;
|
|
approvalRequired: boolean;
|
|
interactionPolicy: InteractionPolicy | null;
|
|
dismissed_clear_links_suggestions: Array<string>;
|
|
clear_link_suggestion: ClearLinkSuggestion | null;
|
|
preview: Partial<BaseStatus> | null;
|
|
}
|
|
|
|
const newCompose = (params: Partial<Compose> = {}): Compose => ({
|
|
caretPosition: null,
|
|
content_type: 'text/plain',
|
|
draft_id: null,
|
|
editorState: null,
|
|
editorStateMap: {},
|
|
focusDate: null,
|
|
group_id: null,
|
|
idempotencyKey: '',
|
|
id: null,
|
|
in_reply_to: null,
|
|
is_changing_upload: false,
|
|
is_composing: false,
|
|
is_submitting: false,
|
|
is_uploading: false,
|
|
media_attachments: [],
|
|
poll: null,
|
|
privacy: 'public',
|
|
progress: 0,
|
|
quote: null,
|
|
resetFileKey: null,
|
|
schedule: null,
|
|
sensitive: false,
|
|
spoiler_text: '',
|
|
spoilerTextMap: {},
|
|
suggestions: [],
|
|
suggestion_token: null,
|
|
tagHistory: [],
|
|
text: '',
|
|
textMap: {},
|
|
to: [],
|
|
parent_reblogged_by: null,
|
|
dismissed_quotes: [],
|
|
language: null,
|
|
modified_language: null,
|
|
suggested_language: null,
|
|
federated: true,
|
|
approvalRequired: false,
|
|
interactionPolicy: null,
|
|
dismissed_clear_links_suggestions: [],
|
|
clear_link_suggestion: null,
|
|
preview: null,
|
|
...params,
|
|
});
|
|
|
|
type State = {
|
|
default: Compose;
|
|
[key: string]: Compose;
|
|
};
|
|
|
|
const statusToTextMentions = (status: Pick<Status, 'account' | 'mentions'>, account: Pick<Account, 'acct'>) => {
|
|
const author = status.account.acct;
|
|
const mentions = status.mentions.map((m) => m.acct) || [];
|
|
|
|
return [...new Set([author, ...mentions].filter(acct => acct !== account.acct))].map(m => `@${m} `).join('');
|
|
};
|
|
|
|
const statusToMentionsArray = (status: Pick<Status, 'account' | 'mentions'>, account: Pick<Account, 'acct'>, rebloggedBy?: Pick<Account, 'acct'>) => {
|
|
const author = status.account.acct;
|
|
const mentions = status.mentions.map((m) => m.acct) || [];
|
|
|
|
return [...new Set([author, ...(rebloggedBy ? [rebloggedBy.acct] : []), ...mentions].filter(acct => acct !== account.acct))];
|
|
};
|
|
|
|
const statusToMentionsAccountIdsArray = (status: Pick<Status, 'mentions' | 'account'>, account: Pick<Account, 'id'>, parentRebloggedBy?: string | null) => {
|
|
const mentions = status.mentions.map((m) => m.id);
|
|
|
|
return [...new Set([status.account.id, ...(parentRebloggedBy ? [parentRebloggedBy] : []), ...mentions].filter((id) => id !== account.id))];
|
|
};
|
|
|
|
const appendMedia = (compose: Compose, media: MediaAttachment, defaultSensitive?: boolean) => {
|
|
const prevSize = compose.media_attachments.length;
|
|
|
|
compose.media_attachments.push(media);
|
|
compose.is_uploading = false;
|
|
compose.resetFileKey = Math.floor((Math.random() * 0x10000));
|
|
compose.idempotencyKey = crypto.randomUUID();
|
|
|
|
if (prevSize === 0 && (defaultSensitive || compose.sensitive)) {
|
|
compose.sensitive = true;
|
|
}
|
|
};
|
|
|
|
const removeMedia = (compose: Compose, mediaId: string) => {
|
|
const prevSize = compose.media_attachments.length;
|
|
|
|
compose.media_attachments = compose.media_attachments.filter(item => item.id !== mediaId);
|
|
compose.idempotencyKey = crypto.randomUUID();
|
|
|
|
if (prevSize === 1) {
|
|
compose.sensitive = false;
|
|
}
|
|
};
|
|
|
|
const insertSuggestion = (compose: Compose, position: number, token: string | null, completion: string, path: ComposeSuggestionSelectAction['path']) => {
|
|
const updateText = (oldText?: string) => `${oldText?.slice(0, position)}${completion} ${oldText?.slice(position + (token?.length ?? 0))}`;
|
|
if (path[0] === 'spoiler_text') {
|
|
compose.spoiler_text = updateText(compose.spoiler_text);
|
|
} else if (compose.poll) {
|
|
compose.poll.options[path[2]] = updateText(compose.poll.options[path[2]]);
|
|
}
|
|
compose.suggestion_token = null;
|
|
compose.suggestions = [];
|
|
compose.idempotencyKey = crypto.randomUUID();
|
|
};
|
|
|
|
const updateSuggestionTags = (compose: Compose, token: string, tags: Tag[]) => {
|
|
const prefix = token.slice(1);
|
|
|
|
compose.suggestions = tags
|
|
.filter((tag) => tag.name.toLowerCase().startsWith(prefix.toLowerCase()))
|
|
.slice(0, 4)
|
|
.map((tag) => '#' + tag.name);
|
|
compose.suggestion_token = token;
|
|
};
|
|
|
|
const privacyPreference = (a: string, b: string, list_id: number | null) => {
|
|
const order = ['public', 'unlisted', 'mutuals_only', 'private', 'direct', 'local'];
|
|
|
|
if (a === 'group') return a;
|
|
if (a === 'list' && list_id !== null) return `list:${list_id}`;
|
|
|
|
return order[Math.max(order.indexOf(a), order.indexOf(b), 0)];
|
|
};
|
|
|
|
const domParser = new DOMParser();
|
|
|
|
const expandMentions = (status: Pick<Status, 'content' | 'mentions'>) => {
|
|
const fragment = domParser.parseFromString(status.content, 'text/html').documentElement;
|
|
|
|
status.mentions.forEach((mention) => {
|
|
const node = fragment.querySelector(`a[href="${mention.url}"]`);
|
|
if (node) node.textContent = `@${mention.acct}`;
|
|
});
|
|
|
|
return fragment.innerHTML;
|
|
};
|
|
|
|
const getExplicitMentions = (me: string, status: Pick<Status, 'content' | 'mentions'>) => {
|
|
const fragment = domParser.parseFromString(status.content, 'text/html').documentElement;
|
|
|
|
const mentions = status
|
|
.mentions
|
|
.filter((mention) => !(fragment.querySelector(`a[href="${mention.url}"]`) || mention.id === me))
|
|
.map((m) => m.acct);
|
|
|
|
return [...new Set(mentions)];
|
|
};
|
|
|
|
const importAccount = (compose: Compose, account: CredentialAccount) => {
|
|
const settings = account.settings_store?.[FE_NAME];
|
|
|
|
if (!settings) return;
|
|
|
|
if (settings.defaultPrivacy) compose.privacy = settings.defaultPrivacy;
|
|
if (settings.defaultContentType) compose.content_type = settings.defaultContentType;
|
|
compose.tagHistory = tagHistory.get(account.id);
|
|
};
|
|
|
|
// const updateSetting = (compose: Compose, path: string[], value: string) => {
|
|
// const pathString = path.join(',');
|
|
// switch (pathString) {
|
|
// case 'defaultPrivacy':
|
|
// return compose.set('privacy', value);
|
|
// case 'defaultContentType':
|
|
// return compose.set('content_type', value);
|
|
// default:
|
|
// return compose;
|
|
// }
|
|
// };
|
|
|
|
const updateDefaultContentType = (compose: Compose, instance: Instance) => {
|
|
const postFormats = instance.pleroma.metadata.post_formats;
|
|
|
|
compose.content_type = postFormats.includes(compose.content_type) || (postFormats.includes('text/markdown') && compose.content_type === 'wysiwyg')
|
|
? compose.content_type
|
|
: postFormats.includes('text/markdown')
|
|
? 'text/markdown'
|
|
: postFormats[0];
|
|
};
|
|
|
|
const updateCompose = (state: State, key: string, updater: (compose: Compose) => void) =>
|
|
create(state, draft => {
|
|
draft[key] = draft[key] || create(draft.default, (draft) => {
|
|
draft.idempotencyKey = crypto.randomUUID();
|
|
});
|
|
updater(draft[key]);
|
|
});
|
|
// state.update(key, state.get('default')!, updater);
|
|
|
|
const initialState: State = {
|
|
default: newCompose({ idempotencyKey: crypto.randomUUID(), resetFileKey: getResetFileKey() }),
|
|
};
|
|
|
|
const compose = (state = initialState, action: ComposeAction | EventsAction | InstanceAction | MeAction | TimelineAction): State => {
|
|
switch (action.type) {
|
|
case COMPOSE_TYPE_CHANGE:
|
|
return updateCompose(state, action.composeId, compose => {
|
|
compose.content_type = action.value;
|
|
compose.idempotencyKey = crypto.randomUUID();
|
|
});
|
|
case COMPOSE_SPOILERNESS_CHANGE:
|
|
return updateCompose(state, action.composeId, compose => {
|
|
compose.sensitive = !compose.sensitive;
|
|
compose.idempotencyKey = crypto.randomUUID();
|
|
});
|
|
case COMPOSE_SPOILER_TEXT_CHANGE:
|
|
return updateCompose(state, action.composeId, compose => {
|
|
if (!compose.modified_language || compose.modified_language === compose.language) {
|
|
compose.spoiler_text = action.text;
|
|
} else if (compose.modified_language) {
|
|
compose.spoilerTextMap[compose.modified_language] = action.text;
|
|
}
|
|
});
|
|
case COMPOSE_VISIBILITY_CHANGE:
|
|
return updateCompose(state, action.composeId, compose => {
|
|
compose.privacy = action.value;
|
|
compose.idempotencyKey = crypto.randomUUID();
|
|
});
|
|
case COMPOSE_LANGUAGE_CHANGE:
|
|
return updateCompose(state, action.composeId, compose => {
|
|
compose.language = action.value;
|
|
compose.modified_language = action.value;
|
|
compose.idempotencyKey = crypto.randomUUID();
|
|
});
|
|
case COMPOSE_MODIFIED_LANGUAGE_CHANGE:
|
|
return updateCompose(state, action.composeId, compose => {
|
|
compose.modified_language = action.value;
|
|
compose.idempotencyKey = crypto.randomUUID();
|
|
});
|
|
case COMPOSE_CHANGE:
|
|
return updateCompose(state, action.composeId, compose => {
|
|
compose.text = action.text;
|
|
compose.idempotencyKey = crypto.randomUUID();
|
|
});
|
|
case COMPOSE_REPLY:
|
|
return updateCompose(state, action.composeId, compose => {
|
|
const defaultCompose = state.default!;
|
|
|
|
const to = action.explicitAddressing
|
|
? statusToMentionsArray(action.status, action.account, action.rebloggedBy)
|
|
: [];
|
|
|
|
compose.group_id = action.status.group_id;
|
|
compose.in_reply_to = action.status.id;
|
|
compose.to = to;
|
|
compose.parent_reblogged_by = action.rebloggedBy?.id || null;
|
|
compose.text = !action.explicitAddressing ? statusToTextMentions(action.status, action.account) : '';
|
|
compose.privacy = privacyPreference(action.status.visibility, defaultCompose.privacy, action.status.list_id);
|
|
compose.focusDate = new Date();
|
|
compose.caretPosition = null;
|
|
compose.idempotencyKey = crypto.randomUUID();
|
|
compose.content_type = defaultCompose.content_type;
|
|
compose.approvalRequired = action.approvalRequired || false;
|
|
if (action.preserveSpoilers && action.status.spoiler_text) {
|
|
compose.sensitive = true;
|
|
compose.spoiler_text = action.status.spoiler_text;
|
|
}
|
|
});
|
|
case COMPOSE_EVENT_REPLY:
|
|
return updateCompose(state, action.composeId, compose => {
|
|
compose.in_reply_to = action.status.id;
|
|
compose.to = statusToMentionsArray(action.status, action.account);
|
|
compose.idempotencyKey = crypto.randomUUID();
|
|
});
|
|
case COMPOSE_QUOTE:
|
|
return updateCompose(state, 'compose-modal', compose => {
|
|
const author = action.status.account.acct;
|
|
const defaultCompose = state.default;
|
|
|
|
compose.quote = action.status.id;
|
|
compose.to = [author];
|
|
compose.parent_reblogged_by = null;
|
|
compose.text = '';
|
|
compose.privacy = privacyPreference(action.status.visibility, defaultCompose.privacy, action.status.list_id);
|
|
compose.focusDate = new Date();
|
|
compose.caretPosition = null;
|
|
compose.idempotencyKey = crypto.randomUUID();
|
|
compose.content_type = defaultCompose.content_type;
|
|
compose.spoiler_text = '';
|
|
|
|
if (action.status.visibility === 'group') {
|
|
compose.group_id = action.status.group_id;
|
|
compose.privacy = 'group';
|
|
}
|
|
});
|
|
case COMPOSE_SUBMIT_REQUEST:
|
|
return updateCompose(state, action.composeId, compose => {
|
|
compose.is_submitting = true;
|
|
});
|
|
case COMPOSE_UPLOAD_CHANGE_REQUEST:
|
|
return updateCompose(state, action.composeId, compose => {
|
|
compose.is_changing_upload = true;
|
|
});
|
|
case COMPOSE_REPLY_CANCEL:
|
|
case COMPOSE_RESET:
|
|
case COMPOSE_SUBMIT_SUCCESS:
|
|
return create(state, (draft) => {
|
|
draft[action.composeId] = create(state.default, (draft) => ({
|
|
...draft,
|
|
idempotencyKey: crypto.randomUUID(),
|
|
in_reply_to: action.composeId.startsWith('reply:') ? action.composeId.slice(6) : null,
|
|
...(action.composeId.startsWith('group:') ? {
|
|
privacy: 'group',
|
|
group_id: action.composeId.slice(6),
|
|
} : undefined),
|
|
}));
|
|
});
|
|
case COMPOSE_SUBMIT_FAIL:
|
|
return updateCompose(state, action.composeId, compose => {
|
|
compose.is_submitting = false;
|
|
});
|
|
case COMPOSE_UPLOAD_CHANGE_FAIL:
|
|
return updateCompose(state, action.composeId, compose => {
|
|
compose.is_changing_upload = false;
|
|
});
|
|
case COMPOSE_UPLOAD_REQUEST:
|
|
return updateCompose(state, action.composeId, compose => {
|
|
compose.is_uploading = true;
|
|
});
|
|
case COMPOSE_UPLOAD_SUCCESS:
|
|
return updateCompose(state, action.composeId, compose => appendMedia(compose, action.media, state.default.sensitive));
|
|
case COMPOSE_UPLOAD_FAIL:
|
|
return updateCompose(state, action.composeId, compose => {
|
|
compose.is_uploading = false;
|
|
});
|
|
case COMPOSE_UPLOAD_UNDO:
|
|
return updateCompose(state, action.composeId, compose => removeMedia(compose, action.mediaId));
|
|
case COMPOSE_UPLOAD_PROGRESS:
|
|
return updateCompose(state, action.composeId, compose => {
|
|
compose.progress = Math.round((action.loaded / action.total) * 100);
|
|
});
|
|
case COMPOSE_MENTION:
|
|
return updateCompose(state, 'compose-modal', compose => {
|
|
compose.text = [compose.text.trim(), `@${action.account.acct} `].filter((str) => str.length !== 0).join(' ');
|
|
compose.focusDate = new Date();
|
|
compose.caretPosition = null;
|
|
compose.idempotencyKey = crypto.randomUUID();
|
|
});
|
|
case COMPOSE_DIRECT:
|
|
return updateCompose(state, 'compose-modal', compose => {
|
|
compose.text = [compose.text.trim(), `@${action.account.acct} `].filter((str) => str.length !== 0).join(' ');
|
|
compose.privacy = 'direct';
|
|
compose.focusDate = new Date();
|
|
compose.caretPosition = null;
|
|
compose.idempotencyKey = crypto.randomUUID();
|
|
});
|
|
case COMPOSE_GROUP_POST:
|
|
return updateCompose(state, action.composeId, compose => {
|
|
compose.privacy = 'group';
|
|
compose.group_id = action.groupId;
|
|
compose.focusDate = new Date();
|
|
compose.caretPosition = null;
|
|
compose.idempotencyKey = crypto.randomUUID();
|
|
});
|
|
case COMPOSE_SUGGESTIONS_CLEAR:
|
|
return updateCompose(state, action.composeId, compose => {
|
|
compose.suggestions = [];
|
|
compose.suggestion_token = null;
|
|
});
|
|
case COMPOSE_SUGGESTIONS_READY:
|
|
return updateCompose(state, action.composeId, compose => {
|
|
compose.suggestions = action.accounts ? action.accounts.map((item) => item.id) : action.emojis || [];
|
|
compose.suggestion_token = action.token;
|
|
});
|
|
case COMPOSE_SUGGESTION_SELECT:
|
|
return updateCompose(state, action.composeId, compose => insertSuggestion(compose, action.position, action.token, action.completion, action.path));
|
|
case COMPOSE_SUGGESTION_TAGS_UPDATE:
|
|
return updateCompose(state, action.composeId, compose => updateSuggestionTags(compose, action.token, action.tags));
|
|
case COMPOSE_TAG_HISTORY_UPDATE:
|
|
return updateCompose(state, action.composeId, compose => {
|
|
compose.tagHistory = action.tags;
|
|
});
|
|
case TIMELINE_DELETE:
|
|
return updateCompose(state, 'compose-modal', compose => {
|
|
if (action.statusId === compose.in_reply_to) {
|
|
compose.in_reply_to = null;
|
|
} if (action.statusId === compose.quote) {
|
|
compose.quote = null;
|
|
}
|
|
});
|
|
case COMPOSE_UPLOAD_CHANGE_SUCCESS:
|
|
return updateCompose(state, action.composeId, compose => {
|
|
compose.is_changing_upload = false;
|
|
|
|
compose.media_attachments = compose.media_attachments.map(item => {
|
|
if (item.id === action.media.id) {
|
|
return action.media;
|
|
}
|
|
|
|
return item;
|
|
});
|
|
});
|
|
case COMPOSE_SET_STATUS:
|
|
return updateCompose(state, 'compose-modal', compose => {
|
|
const to = action.explicitAddressing ? getExplicitMentions(action.status.account.id, action.status) : [];
|
|
if (!action.withRedraft && !action.draftId) {
|
|
compose.id = action.status.id;
|
|
}
|
|
compose.text = action.rawText || unescapeHTML(expandMentions(action.status));
|
|
compose.to = to;
|
|
compose.parent_reblogged_by = null;
|
|
compose.in_reply_to = action.status.in_reply_to_id;
|
|
compose.privacy = action.status.visibility;
|
|
compose.focusDate = new Date();
|
|
compose.caretPosition = null;
|
|
compose.idempotencyKey = crypto.randomUUID();
|
|
const contentType = action.contentType === 'text/markdown' && state.default.content_type === 'wysiwyg'
|
|
? 'wysiwyg'
|
|
: action.contentType || 'text/plain';
|
|
compose.content_type = contentType;
|
|
compose.quote = action.status.quote_id;
|
|
compose.group_id = action.status.group_id;
|
|
compose.language = action.status.language;
|
|
|
|
compose.media_attachments = action.status.media_attachments;
|
|
compose.sensitive = action.status.sensitive;
|
|
|
|
if (action.status.spoiler_text.length > 0) {
|
|
compose.spoiler_text = action.status.spoiler_text;
|
|
} else {
|
|
compose.spoiler_text = '';
|
|
}
|
|
|
|
if (action.poll) {
|
|
compose.poll = newPoll({
|
|
options: action.poll.options.map(({ title }) => title),
|
|
multiple: action.poll.multiple,
|
|
expires_in: 24 * 3600,
|
|
});
|
|
}
|
|
|
|
if (action.draftId) {
|
|
compose.draft_id = action.draftId;
|
|
}
|
|
|
|
if (action.editorState) {
|
|
compose.editorState = action.editorState;
|
|
}
|
|
});
|
|
case COMPOSE_POLL_ADD:
|
|
return updateCompose(state, action.composeId, compose => {
|
|
compose.poll = newPoll();
|
|
});
|
|
case COMPOSE_POLL_REMOVE:
|
|
return updateCompose(state, action.composeId, compose => {
|
|
compose.poll = null;
|
|
});
|
|
case COMPOSE_SCHEDULE_ADD:
|
|
return updateCompose(state, action.composeId, compose => {
|
|
compose.schedule = new Date(Date.now() + 10 * 60 * 1000);
|
|
});
|
|
case COMPOSE_SCHEDULE_SET:
|
|
return updateCompose(state, action.composeId, compose => {
|
|
compose.schedule = action.date;
|
|
});
|
|
case COMPOSE_SCHEDULE_REMOVE:
|
|
return updateCompose(state, action.composeId, compose => {
|
|
compose.schedule = null;
|
|
});
|
|
case COMPOSE_POLL_OPTION_ADD:
|
|
return updateCompose(state, action.composeId, compose => {
|
|
if (!compose.poll) return;
|
|
compose.poll.options.push(action.title);
|
|
compose.poll.options_map.push(Object.fromEntries(Object.entries(compose.textMap).map((key) => [key, action.title])));
|
|
});
|
|
case COMPOSE_POLL_OPTION_CHANGE:
|
|
return updateCompose(state, action.composeId, compose => {
|
|
if (!compose.poll) return;
|
|
if (!compose.modified_language || compose.modified_language === compose.language) {
|
|
compose.poll.options[action.index] = action.title;
|
|
if (compose.modified_language) compose.poll.options_map[action.index][compose.modified_language] = action.title;
|
|
}
|
|
});
|
|
case COMPOSE_POLL_OPTION_REMOVE:
|
|
return updateCompose(state, action.composeId, compose => {
|
|
if (!compose.poll) return;
|
|
compose.poll.options = compose.poll.options.filter((_, index) => index !== action.index);
|
|
compose.poll.options_map = compose.poll.options_map.filter((_, index) => index !== action.index);
|
|
});
|
|
case COMPOSE_POLL_SETTINGS_CHANGE:
|
|
return updateCompose(state, action.composeId, compose => {
|
|
if (!compose.poll) return null;
|
|
if (action.expiresIn) {
|
|
compose.poll.expires_in = action.expiresIn;
|
|
}
|
|
if (typeof action.isMultiple === 'boolean') {
|
|
compose.poll.multiple = action.isMultiple;
|
|
}
|
|
});
|
|
case COMPOSE_ADD_TO_MENTIONS:
|
|
return updateCompose(state, action.composeId, compose => {
|
|
compose.to = [...new Set([...compose.to, action.account])];
|
|
});
|
|
case COMPOSE_REMOVE_FROM_MENTIONS:
|
|
return updateCompose(state, action.composeId, compose => {
|
|
compose.to = compose.to.filter(acct => acct !== action.account);
|
|
});
|
|
case ME_FETCH_SUCCESS:
|
|
case ME_PATCH_SUCCESS:
|
|
return updateCompose(state, 'default', compose => importAccount(compose, action.me));
|
|
// case SETTING_CHANGE:
|
|
// return updateCompose(state, 'default', compose => updateSetting(compose, action.path, action.value));
|
|
case COMPOSE_EDITOR_STATE_SET:
|
|
return updateCompose(state, action.composeId, compose => {
|
|
if (!compose.modified_language || compose.modified_language === compose.language) {
|
|
compose.editorState = action.editorState as string;
|
|
compose.text = action.text as string;
|
|
} else if (compose.modified_language) {
|
|
compose.editorStateMap[compose.modified_language] = action.editorState as string;
|
|
compose.textMap[compose.modified_language] = action.text as string;
|
|
}
|
|
});
|
|
case EVENT_COMPOSE_CANCEL:
|
|
return updateCompose(state, 'event-compose-modal', compose => {
|
|
compose.text = '';
|
|
});
|
|
case EVENT_FORM_SET:
|
|
return updateCompose(state, action.composeId, compose => {
|
|
compose.text = action.text;
|
|
});
|
|
case COMPOSE_CHANGE_MEDIA_ORDER:
|
|
return updateCompose(state, action.composeId, compose => {
|
|
const indexA = compose.media_attachments.findIndex(x => x.id === action.a);
|
|
const indexB = compose.media_attachments.findIndex(x => x.id === action.b);
|
|
|
|
const item = compose.media_attachments.splice(indexA, 1)[0];
|
|
compose.media_attachments.splice(indexB, 0, item);
|
|
});
|
|
case COMPOSE_ADD_SUGGESTED_QUOTE:
|
|
return updateCompose(state, action.composeId, compose => {
|
|
compose.quote = action.quoteId;
|
|
});
|
|
case COMPOSE_ADD_SUGGESTED_LANGUAGE:
|
|
return updateCompose(state, action.composeId, compose => {
|
|
compose.suggested_language = action.language;
|
|
});
|
|
case COMPOSE_LANGUAGE_ADD:
|
|
return updateCompose(state, action.composeId, compose => {
|
|
compose.editorStateMap[action.value] = compose.editorState;
|
|
compose.textMap[action.value] = compose.text;
|
|
compose.spoilerTextMap[action.value] = compose.spoiler_text;
|
|
if (compose.poll) compose.poll.options_map.forEach((option, key) => option[action.value] = compose.poll!.options[key]);
|
|
});
|
|
case COMPOSE_LANGUAGE_DELETE:
|
|
return updateCompose(state, action.composeId, compose => {
|
|
delete compose.editorStateMap[action.value];
|
|
delete compose.textMap[action.value];
|
|
delete compose.spoilerTextMap[action.value];
|
|
});
|
|
case COMPOSE_QUOTE_CANCEL:
|
|
return updateCompose(state, action.composeId, (compose) => {
|
|
if (compose.quote) compose.dismissed_quotes.push(compose.quote);
|
|
compose.quote = null;
|
|
});
|
|
case COMPOSE_FEDERATED_CHANGE:
|
|
return updateCompose(state, action.composeId, compose => {
|
|
compose.federated = !compose.federated;
|
|
});
|
|
case COMPOSE_INTERACTION_POLICY_OPTION_CHANGE:
|
|
return updateCompose(state, action.composeId, compose => {
|
|
if (compose.interactionPolicy === null) compose.interactionPolicy = JSON.parse(JSON.stringify(action.initial))!;
|
|
|
|
compose.interactionPolicy = create(compose.interactionPolicy || action.initial, (interactionPolicy) => {
|
|
interactionPolicy[action.policy][action.rule] = action.value;
|
|
interactionPolicy[action.policy][action.rule === 'always' ? 'with_approval' : 'always'] = interactionPolicy[action.policy][action.rule === 'always' ? 'with_approval' : 'always'].filter(rule => !action.value.includes(rule as any));
|
|
});
|
|
});
|
|
case INSTANCE_FETCH_SUCCESS:
|
|
return updateCompose(state, 'default', (compose) => updateDefaultContentType(compose, action.instance));
|
|
case COMPOSE_CLEAR_LINK_SUGGESTION_CREATE:
|
|
return updateCompose(state, action.composeId, compose => {
|
|
compose.clear_link_suggestion = action.suggestion;
|
|
});
|
|
case COMPOSE_CLEAR_LINK_SUGGESTION_IGNORE:
|
|
return updateCompose(state, action.composeId, compose => {
|
|
if (compose.clear_link_suggestion?.key === action.key) {
|
|
compose.clear_link_suggestion = null;
|
|
}
|
|
compose.dismissed_clear_links_suggestions.push(action.key);
|
|
});
|
|
case COMPOSE_PREVIEW_SUCCESS:
|
|
return updateCompose(state, action.composeId, compose => {
|
|
compose.preview = action.status;
|
|
});
|
|
case COMPOSE_PREVIEW_CANCEL:
|
|
return updateCompose(state, action.composeId, compose => {
|
|
compose.preview = null;
|
|
});
|
|
default:
|
|
return state;
|
|
}
|
|
};
|
|
|
|
export {
|
|
type Compose,
|
|
type ClearLinkSuggestion,
|
|
statusToMentionsAccountIdsArray,
|
|
initialState,
|
|
compose as default,
|
|
};
|