concord 2.5.20

A terminal user interface client for Discord
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

use crate::discord::MessageAttachmentUpload;
use crate::tui::state::LocalUploadPreviewView;
use ratatui_image::protocol::Protocol;

#[derive(Debug)]
pub(in crate::tui::state) struct LocalUploadPreviewState {
    pub(in crate::tui::state) attachment_index: usize,
    pub(in crate::tui::state) generation: u64,
    pub(in crate::tui::state) filename: String,
    pub(in crate::tui::state) state: LocalUploadPreviewStatus,
}

pub(in crate::tui::state) enum LocalUploadPreviewStatus {
    Pending,
    Loading,
    Ready(Protocol),
    Failed(String),
}

impl std::fmt::Debug for LocalUploadPreviewStatus {
    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::Pending => formatter.write_str("Pending"),
            Self::Loading => formatter.write_str("Loading"),
            Self::Ready(_) => formatter.write_str("Ready(<protocol>)"),
            Self::Failed(message) => formatter.debug_tuple("Failed").field(message).finish(),
        }
    }
}

pub(in crate::tui::state) fn local_upload_preview_view(
    preview: &LocalUploadPreviewState,
) -> LocalUploadPreviewView<'_> {
    match &preview.state {
        LocalUploadPreviewStatus::Pending | LocalUploadPreviewStatus::Loading => {
            LocalUploadPreviewView::Loading {
                filename: &preview.filename,
            }
        }
        LocalUploadPreviewStatus::Ready(protocol) => LocalUploadPreviewView::Ready { protocol },
        LocalUploadPreviewStatus::Failed(message) => LocalUploadPreviewView::Failed {
            filename: &preview.filename,
            message,
        },
    }
}

pub(in crate::tui::state) fn sync_local_upload_previews(
    attachments: &[MessageAttachmentUpload],
    previews: &mut Vec<LocalUploadPreviewState>,
    generation: &mut u64,
    enabled: bool,
) {
    if !enabled {
        previews.clear();
        return;
    }

    let mut previous = std::mem::take(previews);
    *previews = attachments
        .iter()
        .enumerate()
        .filter(|(_, attachment)| local_upload_preview_candidate(attachment))
        .map(|(attachment_index, attachment)| {
            if let Some(previous_index) = previous.iter().position(|preview| {
                preview.attachment_index == attachment_index
                    && preview.filename == attachment.filename
            }) {
                return previous.remove(previous_index);
            }
            *generation = generation.saturating_add(1);
            LocalUploadPreviewState {
                attachment_index,
                generation: *generation,
                filename: attachment.filename.clone(),
                state: LocalUploadPreviewStatus::Pending,
            }
        })
        .collect();
}

pub(in crate::tui::state) fn take_pending_local_upload_preview(
    previews: &mut [LocalUploadPreviewState],
    attachments: &[MessageAttachmentUpload],
) -> Option<(usize, u64, String, MessageAttachmentUpload)> {
    let preview = previews
        .iter_mut()
        .find(|preview| matches!(preview.state, LocalUploadPreviewStatus::Pending))?;
    let attachment = attachments.get(preview.attachment_index)?.clone();
    preview.state = LocalUploadPreviewStatus::Loading;
    Some((
        preview.attachment_index,
        preview.generation,
        preview.filename.clone(),
        attachment,
    ))
}

pub(in crate::tui::state) fn store_local_upload_preview_result(
    previews: &mut [LocalUploadPreviewState],
    attachment_index: usize,
    generation: u64,
    filename: String,
    result: Result<Protocol, String>,
) {
    let Some(preview) = previews.iter_mut().find(|preview| {
        preview.attachment_index == attachment_index && preview.generation == generation
    }) else {
        return;
    };
    preview.filename = filename;
    preview.state = match result {
        Ok(protocol) => LocalUploadPreviewStatus::Ready(protocol),
        Err(message) => LocalUploadPreviewStatus::Failed(message),
    };
}

pub(in crate::tui::state) fn local_upload_preview_candidate(
    attachment: &MessageAttachmentUpload,
) -> bool {
    let Some(extension) = attachment
        .filename
        .rsplit('.')
        .next()
        .filter(|extension| *extension != attachment.filename)
    else {
        return false;
    };
    matches!(
        extension.to_ascii_lowercase().as_str(),
        "png" | "jpg" | "jpeg" | "gif" | "webp" | "bmp" | "tif" | "tiff"
    )
}