update deps and work with kittage 0.4

Cargo.toml

@@ -11,7 +11,7 @@ license = "AGPL-3.0-only"
 keywords = ["pdf", "tui", "cli", "terminal"]
 categories = ["command-line-utilities", "text-processing", "visualization"]
 default-run = "tdf"
-rust-version = "1.86"
+rust-version = "1.90"
 
 [[bin]]
 name = "tdf"
@@ -41,10 +41,11 @@ nix = { version = "0.31.0", features = ["signal"] }
 mupdf = { git = "https://github.com/messense/mupdf-rs.git", rev = "d7441b9998c92135e329559c0aa71d9dc92cf4de", default-features = false, features = ["svg", "system-fonts", "img"] }
 rayon = { version = "1", default-features = false }
 # kittage = { path = "../kittage/", features = ["crossterm-tokio", "image-crate", "log"] }
-kittage = { version = "0.3.4", features = ["crossterm-tokio", "image-crate", "log"] }
+kittage = { version = "0.4.0", features = ["crossterm-tokio", "image-crate", "log"] }
 memmap2 = "0"
 csscolorparser = { version = "0.8.0", default-features = false }
 debounce = "0.2.2"
+smallvec = "1"
 
 # logging
 log = "0.4.27"

src/converter.rs

@@ -1,13 +1,13 @@
 use std::{
 	io::Cursor,
-	num::NonZeroUsize,
+	num::{NonZeroUsize, NonZeroU32},
 	time::{SystemTime, UNIX_EPOCH}
 };
 
 use flume::{Receiver, SendError, Sender, TryRecvError};
 use futures_util::stream::StreamExt as _;
 use image::{DynamicImage, codecs::pnm::PnmDecoder};
-use kittage::{NumberOrId, action::NONZERO_ONE};
+use kittage::NumberOrId;
 use ratatui::layout::Rect;
 use ratatui_image::{
 	Resize,
@@ -164,7 +164,7 @@ pub async fn run_conversion_loop(
 				};
 
 				// if ur pdf has 4 billion pages then you deserve to suffer
-				img.num_or_id = NumberOrId::Id(NONZERO_ONE.saturating_add(page_num as u32));
+				img.num_or_id = NumberOrId::Id(NonZeroU32::MIN.saturating_add(page_num as u32));
 
 				ConvertedImage::Kitty {
 					img: MaybeTransferred::NotYet(img),

src/kitty.rs

@@ -1,3 +1,4 @@
+use core::fmt::Display;
 use std::{io::Write, num::NonZeroU32};
 
 use crossterm::{
@@ -17,6 +18,7 @@ use kittage::{
 	medium::Medium
 };
 use ratatui::layout::Position;
+use smallvec::SmallVec;
 
 use crate::converter::MaybeTransferred;
 
@@ -63,7 +65,7 @@ impl<W: Write> Write for DbgWriter<W> {
 pub async fn run_action<'es>(
 	action: Action<'_, '_>,
 	ev_stream: &'es mut EventStream
-) -> Result<ImageId, TransmitError<<&'es mut EventStream as AsyncInputReader>::Error>> {
+) -> Result<Option<ImageId>, TransmitError<<&'es mut EventStream as AsyncInputReader>::Error>> {
 	let writer = DbgWriter {
 		w: std::io::stdout().lock(),
 		#[cfg(debug_assertions)]
@@ -99,17 +101,43 @@ pub async fn do_shms_work(ev_stream: &mut EventStream) -> bool {
 	res.is_ok()
 }
 
+type ESTransErr<'es> = TransmitError<<&'es mut EventStream as AsyncInputReader>::Error>;
+
+pub struct DisplayErr<'es> {
+	pub failed_pages: SmallVec<[usize; 2]>,
+	pub user_facing_err: &'static str,
+	pub source: DisplayErrSource<'es>
+}
+
+impl<'es> DisplayErr<'es> {
+	fn empty(user_facing_err: &'static str, source: ESTransErr<'es>) -> Self {
+		Self {
+			failed_pages: SmallVec::new(),
+			user_facing_err,
+			source: DisplayErrSource::Transmission(source)
+		}
+	}
+}
+
+#[derive(Debug)]
+pub enum DisplayErrSource<'es> {
+	KittageReturnedNoId,
+	Transmission(ESTransErr<'es>)
+}
+
+impl Display for DisplayErrSource<'_> {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		match self {
+			Self::KittageReturnedNoId => write!(f, "Kittage returned no ID when we asked it to display an image. This is a bug in kittage, please report it."),
+			Self::Transmission(t) => write!(f, "Error with talking to the terminal: {t}"),
+		}
+	}
+}
+
 pub async fn display_kitty_images<'es>(
 	display: KittyDisplay<'_>,
 	ev_stream: &'es mut EventStream
-) -> Result<
-	(),
-	(
-		Vec<usize>,
-		&'static str,
-		TransmitError<<&'es mut EventStream as AsyncInputReader>::Error>
-	)
-> {
+) -> Result<(), DisplayErr<'es>> {
 	let images = match display {
 		KittyDisplay::NoChange => return Ok(()),
 		KittyDisplay::DisplayImages(_) | KittyDisplay::ClearImages => {
@@ -121,7 +149,7 @@ pub async fn display_kitty_images<'es>(
 				ev_stream
 			)
 			.await
-			.map_err(|e| (vec![], "Couldn't clear previous images", e))?;
+			.map_err(|e| DisplayErr::empty("Couldn't clear previous images", e))?;
 
 			let KittyDisplay::DisplayImages(images) = display else {
 				return Ok(());
@@ -131,7 +159,7 @@ pub async fn display_kitty_images<'es>(
 		}
 	};
 
-	let mut err = None;
+	let mut err = Ok::<(), (SmallVec<[usize; 2]>, DisplayErrSource<'es>)>(());
 	for KittyReadyToDisplay {
 		img,
 		page_num,
@@ -179,11 +207,12 @@ pub async fn display_kitty_images<'es>(
 				.await;
 
 				match res {
-					Ok(img_id) => {
+					Ok(Some(img_id)) => {
 						*img = MaybeTransferred::Transferred(img_id);
 						Ok(())
-					}
-					Err(e) => Err((page_num, e))
+					},
+					Ok(None) => Err((page_num, DisplayErrSource::KittageReturnedNoId)),
+					Err(e) => Err((page_num, DisplayErrSource::Transmission(e)))
 				}
 			}
 			MaybeTransferred::Transferred(image_id) => run_action(
@@ -195,20 +224,24 @@ pub async fn display_kitty_images<'es>(
 				ev_stream
 			)
 			.await
-			.map(|_| ())
-			.map_err(|e| (page_num, e))
+			// don't need the return id 'cause we already know it
+			.map(|_: Option<ImageId>| ())
+			.map_err(|e| (page_num, DisplayErrSource::Transmission(e)))
 		};
 
 		log::debug!("this_err is {this_err:#?}");
 
 		if let Err((id, e)) = this_err {
-			let e = err.get_or_insert_with(|| (vec![], e));
-			e.0.push(id);
+			match err.as_mut() {
+				Ok(()) => err = Err((SmallVec::from([id].as_slice()), e)),
+				Err((v, _)) => v.push(id)
+			}
 		}
 	}
 
-	match err {
-		Some((replace, e)) => Err((replace, "Couldn't transfer image to the terminal", e)),
-		None => Ok(())
-	}
+	err.map_err(|(failed_pages, source)| DisplayErr {
+		failed_pages,
+		user_facing_err: "Couldn't transfer image to the terminal",
+		source
+	})
 }

src/main.rs

@@ -38,7 +38,7 @@ use ratatui_image::{
 use tdf::{
 	PrerenderLimit,
 	converter::{ConvertedPage, ConverterMsg, run_conversion_loop},
-	kitty::{KittyDisplay, display_kitty_images, do_shms_work, run_action},
+	kitty::{DisplayErr, DisplayErrSource, KittyDisplay, display_kitty_images, do_shms_work, run_action},
 	renderer::{self, MUPDF_BLACK, MUPDF_WHITE, RenderError, RenderInfo, RenderNotif},
 	tui::{BottomMessage, InputAction, MessageSetting, Tui}
 };
@@ -462,8 +462,8 @@ async fn enter_redraw_loop(
 
 			let maybe_err = display_kitty_images(to_display, &mut ev_stream).await;
 
-			if let Err((to_replace, err_desc, enum_err)) = maybe_err {
-				match enum_err {
+			if let Err(DisplayErr { failed_pages, user_facing_err, source }) = maybe_err {
+				match source {
 					// This is the error that kitty & ghostty provide us when they delete an
 					// image due to memory constraints, so if we get it, we just fix it by
 					// re-rendering so it don't display it to the user
@@ -471,13 +471,13 @@ async fn enter_redraw_loop(
 					// [TODO] maybe when we detect that an image was deleted, we probe the
 					// terminal for the pages around it to see if they were deleted too and if
 					// they were, we re-render them? idk
-					TransmitError::Terminal(TerminalError::NoEntity(_)) => (),
+					DisplayErrSource::Transmission(TransmitError::Terminal(TerminalError::NoEntity(_))) => (),
 					_ => tui.set_msg(MessageSetting::Some(BottomMessage::Error(format!(
-						"{err_desc}: {enum_err}"
+						"{user_facing_err}: {source}"
 					))))
 				}
 
-				for page_num in to_replace {
+				for page_num in failed_pages {
 					tui.page_failed_display(page_num);
 					// So that they get re-rendered and sent over again
 					to_renderer.send(RenderNotif::PageNeedsReRender(page_num))?;