Remove unneeded DIACRITICS_ZERO and Spans with ZERO_WIDTH_SPACE

I found out kitty does not need to have the DIACRITICS_ZERO specified,
and we can avoid it entirely.
This also removes the Spans(ZERO_WIDTH_SPACE) between emotes/text, as
they are not needed, and were causing rendering issues with ratatui.

src/handlers/data.rs

@@ -17,8 +17,8 @@
     utils::{
         colors::{hsl_to_rgb, u32_to_color},
         emotes::{
-            get_emote_offset, UnicodePlaceholder, DIACRITICS_ZERO, PRIVATE_USE_UNICODE,
-            ZERO_WIDTH_SPACE, ZERO_WIDTH_SPACE_STR,
+            get_emote_offset, UnicodePlaceholder, PRIVATE_USE_UNICODE, ZERO_WIDTH_SPACE,
+            ZERO_WIDTH_SPACE_STR,
         },
         styles::{
             DATETIME_DARK, DATETIME_LIGHT, HIGHLIGHT_NAME_DARK, HIGHLIGHT_NAME_LIGHT, SYSTEM_CHAT,
@@ -104,7 +104,7 @@
                         return Some(s.len() - 1 - chars.as_str().len());
                     }
                 }
                 None
             })
             .collect()
     }
@@ -117,8 +117,8 @@
             *emotes = &emotes[1..];
             Span::styled(content, Style::default().fg(id).underline_color(pid))
         } else {
             error!("Emote index >= emotes.len()");
             Span::raw(content)
         }
     }
 
@@ -197,22 +197,20 @@
                     ));
                 }
                 *start_index += ZERO_WIDTH_SPACE_STR.len();
-                spans.push(Span::raw(ZERO_WIDTH_SPACE_STR));
             }
 
             *start_index = start_index.saturating_sub(ZERO_WIDTH_SPACE_STR.len());
-            spans.pop();
             spans
         }
     }
 
     pub fn to_vec(
         &self,
         frontend_config: &FrontendConfig,
         width: usize,
         search_highlight: Option<&str>,
         username_highlight: Option<&str>,
     ) -> Vec<Line> {
         // Theme styles
         let username_theme = match frontend_config.theme {
             Theme::Dark => HIGHLIGHT_NAME_DARK,
@@ -234,7 +232,7 @@
             .map(|name| {
                 self.payload
                     .match_indices(name)
                     .flat_map(|(index, _)| index..(index + name.len()))
                     .collect::<Vec<usize>>()
             })
             .unwrap_or_default();
@@ -244,11 +242,11 @@
             .and_then(|query| {
                 FUZZY_FINDER
                     .fuzzy_indices(&self.payload, query)
                     .map(|(_, indices)| {
                         // `username_highlight` indices are byte indices, whereas `fuzzy_indices` returns char indices.
                         // Convert those char indices to byte indices, which are easier to work with.
                         Self::char_to_byte_indices(&self.payload, indices.into_iter())
                     })
             })
             .unwrap_or_default();
 
@@ -256,22 +254,22 @@
         let username = (&username_highlight as &[usize], username_theme);
 
         // Message prefix
         let time_sent = if frontend_config.show_datetimes {
             Some(
                 self.time_sent
                     .format(&frontend_config.datetime_format)
                     .to_string(),
             )
         } else {
             None
         };
 
         // Add 1 for the space after the timestamp
         let time_sent_len = time_sent.as_ref().map_or(0, |t| t.len() + 1);
 
         let prefix_len = if frontend_config.username_shown {
             // Add 2 for the ": "
             time_sent_len + self.author.len() + 2
         } else {
             time_sent_len
         };
@@ -293,19 +291,19 @@
 
         let username_alignment = if frontend_config.username_shown {
             if frontend_config.right_align_usernames {
                 NAME_MAX_CHARACTERS.saturating_sub(self.author.width()) + 1
             } else {
                 1
             }
         } else {
             1
         };
 
         let mut first_row: Vec<Span<'_>> = vec![];
 
         if let Some(t) = time_sent {
             first_row.extend(vec![
                 Span::styled(t, datetime_theme),
                 Span::raw(" ".repeat(username_alignment)),
             ]);
         }
@@ -313,7 +311,7 @@
         if frontend_config.username_shown {
             first_row.extend(vec![
                 Span::styled(&self.author, author_theme),
                 Span::raw(": "),
             ]);
         }
 
@@ -321,27 +319,27 @@
 
         // Unwrapping is safe because of the empty check above
         let mut first_line = lines.next().unwrap();
         let first_line_msg = split_cow_in_place(&mut first_line, prefix_len);
 
         let mut emotes = &self.emotes[..];
 
         first_row.extend(Self::build_line(
             first_line_msg,
             &mut next_index,
             search,
             username,
             &mut emotes,
         ));
 
         let mut rows = vec![Line::from(first_row)];
 
         rows.extend(lines.map(|line| {
             Line::from(Self::build_line(
                 line,
                 &mut next_index,
                 search,
                 username,
                 &mut emotes,
             ))
         }));
 
@@ -353,103 +351,100 @@
     /// The emote will then be displayed by the terminal by encoding its id in its foreground color, and its pid in its underline color.
     /// Ratatui removes all ansi escape sequences, so the id/pid of the emote is stored and encoded in [`MessageData::to_vec`].
     pub fn parse_emotes(&mut self, emotes: &mut Emotes) {
         if emotes.emotes.is_empty() {
             return;
         }
 
         let mut words = Vec::new();
 
         self.payload.split(' ').for_each(|word| {
             let Some((filename, zero_width)) = emotes.emotes.get(word) else {
                 words.push(Word::Text(word.to_string()));
                 return;
             };
 
             let Ok(loaded_emote) = load_emote(
                 word,
                 filename,
                 *zero_width,
                 &mut emotes.info,
                 emotes.cell_size,
             )
             .map_err(|e| warn!("Unable to load emote {word} ({filename}): {e}")) else {
                 emotes.emotes.remove(word);
                 words.push(Word::Text(word.to_string()));
                 return;
             };
 
             if loaded_emote.overlay {
                 // Check if last word is emote.
                 if let Some(Word::Emote(v)) = words.last_mut() {
                     v.push(loaded_emote.into());
                     return;
                 }
             }
 
             words.push(Word::Emote(vec![loaded_emote.into()]));
         });
 
         self.payload.clear();
 
         // Join words by space, or by zero-width spaces if one of them is an emote.
         for w in words {
             match w {
                 Word::Text(s) => {
                     if !self.payload.is_empty() {
-                        self.payload.push(
-                            if self.payload.ends_with(PRIVATE_USE_UNICODE)
-                                || self.payload.ends_with(DIACRITICS_ZERO)
-                            {
+                        self.payload
+                            .push(if self.payload.ends_with(PRIVATE_USE_UNICODE) {
                                 ZERO_WIDTH_SPACE
                             } else {
                                 ' '
-                            },
-                        );
+                            });
                     }
                     self.payload.push_str(&s);
                 }
                 Word::Emote(v) => {
                     // Unwrapping here is fine as v is never empty.
                     let max_width = v
                         .iter()
                         .max_by_key(|e| e.width)
                         .expect("Emotes should never be empty")
                         .width as f32;
                     let cols = (max_width / emotes.cell_size.0).ceil() as u16;
 
                     let mut iter = v.into_iter();
 
                     let EmoteData { id, pid, width } = iter.next().unwrap();
 
                     let (_, col_offset) =
                         get_emote_offset(width as u16, emotes.cell_size.0 as u16, cols);
 
                     if let Err(e) = display_emote(id, pid, cols) {
                         warn!("Unable to display emote: {e}");
                         continue;
                     }
 
                     iter.enumerate().for_each(|(layer, emote)| {
                         if let Err(e) = overlay_emote(
                             (id, pid),
                             emote,
                             layer as u32,
                             cols,
                             col_offset,
                             emotes.cell_size.0 as u16,
                         ) {
                             warn!("Unable to display overlay: {e}");
                         }
                     });
 
                     self.emotes.push((u32_to_color(id), u32_to_color(pid)));
 
                     if !self.payload.is_empty() {
                         self.payload.push(ZERO_WIDTH_SPACE);
                     }
 
                     self.payload
                         .extend(UnicodePlaceholder::new(cols as usize).iter());
                 }
             }
         }
@@ -674,13 +669,9 @@
             spans,
             vec![
                 Span::raw("foo"),
-                Span::raw(ZERO_WIDTH_SPACE_STR),
                 Span::styled(emote_w_3, STYLES[0]),
-                Span::raw(ZERO_WIDTH_SPACE_STR),
                 Span::styled(emote_w_1, STYLES[1]),
-                Span::raw(ZERO_WIDTH_SPACE_STR),
                 Span::raw("bar baz"),
-                Span::raw(ZERO_WIDTH_SPACE_STR),
                 Span::styled(emote_w_2, STYLES[2]),
             ]
         );
@@ -762,11 +753,8 @@
             spans,
             vec![
                 Span::raw("foo"),
-                Span::raw(ZERO_WIDTH_SPACE_STR),
                 Span::styled(emote_w_3, STYLES[0]),
-                Span::raw(ZERO_WIDTH_SPACE_STR),
                 Span::styled(emote_w_1, STYLES[1]),
-                Span::raw(ZERO_WIDTH_SPACE_STR),
                 Span::styled("b", STYLES[1]),
                 Span::styled("a", STYLES[1]),
                 Span::raw("r"),
@@ -776,7 +764,6 @@
                 Span::styled("b", STYLES[0]),
                 Span::styled("a", STYLES[1]),
                 Span::raw("z"),
-                Span::raw(ZERO_WIDTH_SPACE_STR),
                 Span::styled(emote_w_2, STYLES[2]),
             ]
         );

src/utils/emotes.rs

@@ -2,17 +2,15 @@
 use std::iter;
 
 pub const PRIVATE_USE_UNICODE: char = '\u{10EEEE}';
-pub const DIACRITICS_ZERO: char = '\u{305}';
-
 pub const ZERO_WIDTH_SPACE: char = '\u{200B}';
 pub const ZERO_WIDTH_SPACE_STR: &str = "\u{200B}";
 
 pub const fn emotes_enabled(frontend: &FrontendConfig) -> bool {
     frontend.twitch_emotes
         || frontend.betterttv_emotes
         || frontend.seventv_emotes
         || frontend.frankerfacez_emotes
 }
 
 pub const fn get_emote_offset(width: u16, cell_width: u16, cols: u16) -> (u16, u16) {
     let w = (width + if cols % 2 == 0 { 0 } else { cell_width } + 1) / 2;
@@ -32,27 +30,20 @@
 ///
 /// A unicode placeholder consists of multiple [`PRIVATE_USE_UNICODE`] so that it takes the same amount of space on screen as the image.
 ///
-/// [`PRIVATE_USE_UNICODE`] characters need to be followed by a diacritic indicating their position in the image.
-/// For [`PRIVATE_USE_UNICODE`] adjacent to each other, only the first one needs to indicate its position.
-/// The position for the other ones will be deduced automatically.
-///
-/// As all twitch emotes have a height of 1 row, we only need the [`DIACRITICS_ZERO`], which indicates a position of `(col, row) = (0, 0)`.
-///
-/// The format for a Unicode placeholder is `{PRIVATE_USE_UNICODE} + {DIACRITICS_ZERO} + {PRIVATE_USE_UNICODE} * (width - 1)`
+/// The format for a Unicode placeholder is `{PRIVATE_USE_UNICODE} * width`
 ///
 /// [Reference](https://sw.kovidgoyal.net/kitty/graphics-protocol/#unicode-placeholders)
 pub struct UnicodePlaceholder(usize);
 
 impl UnicodePlaceholder {
     pub const fn new(width: usize) -> Self {
         assert!(width > 0);
-        // Add 1 for the diacritic
-        Self(width + 1)
+        Self(width)
     }
 
     #[allow(unused)]
     pub const fn len(&self) -> usize {
-        DIACRITICS_ZERO.len_utf8() + PRIVATE_USE_UNICODE.len_utf8() * (self.0 - 1)
+        PRIVATE_USE_UNICODE.len_utf8() * self.0
     }
 
     pub fn iter(&'_ self) -> impl Iterator<Item = char> + '_ {
@@ -62,8 +53,6 @@
 
             if count > self.0 {
                 None
-            } else if count == 2 {
-                Some(DIACRITICS_ZERO)
             } else {
                 Some(PRIVATE_USE_UNICODE)
             }
@@ -172,30 +161,24 @@
     fn unicode_placeholders() {
         assert_eq!(
             UnicodePlaceholder::new(1).string(),
-            format!("{PRIVATE_USE_UNICODE}{DIACRITICS_ZERO}")
+            format!("{PRIVATE_USE_UNICODE}")
         );
         assert_eq!(
             UnicodePlaceholder::new(2).string(),
-            format!("{PRIVATE_USE_UNICODE}{DIACRITICS_ZERO}{PRIVATE_USE_UNICODE}")
+            format!("{PRIVATE_USE_UNICODE}{PRIVATE_USE_UNICODE}")
         );
         assert_eq!(
             UnicodePlaceholder::new(3).string(),
-            format!(
-                "{PRIVATE_USE_UNICODE}{DIACRITICS_ZERO}{PRIVATE_USE_UNICODE}{PRIVATE_USE_UNICODE}"
-            )
+            format!("{PRIVATE_USE_UNICODE}{PRIVATE_USE_UNICODE}{PRIVATE_USE_UNICODE}")
         );
 
         let up = UnicodePlaceholder::new(3);
 
-        assert_eq!(
-            up.len(),
-            PRIVATE_USE_UNICODE.len_utf8() * 3 + DIACRITICS_ZERO.len_utf8()
-        );
+        assert_eq!(up.len(), PRIVATE_USE_UNICODE.len_utf8() * 3);
 
         let mut iter = up.iter();
 
         assert_eq!(iter.next(), Some(PRIVATE_USE_UNICODE));
-        assert_eq!(iter.next(), Some(DIACRITICS_ZERO));
         assert_eq!(iter.next(), Some(PRIVATE_USE_UNICODE));
         assert_eq!(iter.next(), Some(PRIVATE_USE_UNICODE));
         assert_eq!(iter.next(), None);