get correct cursor pos when menu indicator contains newline

src/lib.rs

@@ -277,7 +277,8 @@ pub use validator::{DefaultValidator, ValidationResult, Validator};
 
 mod menu;
 pub use menu::{
-    menu_functions, ColumnarMenu, IdeMenu, ListMenu, Menu, MenuEvent, MenuTextStyle, ReedlineMenu,
+    menu_functions, ColumnarMenu, DescriptionMode, IdeMenu, ListMenu, Menu, MenuEvent,
+    MenuTextStyle, ReedlineMenu,
 };
 
 mod terminal_extensions;

src/menu/ide_menu.rs

@@ -11,6 +11,7 @@
 use unicode_segmentation::UnicodeSegmentation;
 use unicode_width::UnicodeWidthStr;
 
+/// The direction of the description box
 pub enum DescriptionMode {
     /// Description is always shown on the left
     Left,
@@ -32,16 +33,16 @@
 }
 
 impl Default for BorderSymbols {
     fn default() -> Self {
         Self {
             top_left: '╭',
             top_right: '╮',
             bottom_left: '╰',
             bottom_right: '╯',
             horizontal: '─',
             vertical: '│',
         }
     }
 }
 
 /// Default values used as reference for the menu. These values are set during
@@ -174,156 +175,156 @@
 
     /// Menu builder with new value for text style
     #[must_use]
     pub fn with_text_style(mut self, text_style: Style) -> Self {
         self.color.text_style = text_style;
         self
     }
 
     /// Menu builder with new value for text style
     #[must_use]
     pub fn with_selected_text_style(mut self, selected_text_style: Style) -> Self {
         self.color.selected_text_style = selected_text_style;
         self
     }
 
     /// Menu builder with new value for text style
     #[must_use]
     pub fn with_description_text_style(mut self, description_text_style: Style) -> Self {
         self.color.description_style = description_text_style;
         self
     }
 
     /// Menu builder with new value for min completion width value
     #[must_use]
     pub fn with_min_completion_width(mut self, width: u16) -> Self {
         self.default_details.min_completion_width = width;
         self
     }
 
     /// Menu builder with new value for max completion width value
     #[must_use]
     pub fn with_max_completion_width(mut self, width: u16) -> Self {
         self.default_details.max_completion_width = width;
         self
     }
 
     /// Menu builder with new value for max completion height value
     #[must_use]
     pub fn with_max_completion_height(mut self, height: u16) -> Self {
         self.default_details.max_completion_height = height;
         self
     }
 
     /// Menu builder with new value for padding value
     #[must_use]
     pub fn with_padding(mut self, padding: u16) -> Self {
         self.default_details.padding = padding;
         self
     }
 
     /// Menu builder with the default border value
     #[must_use]
     pub fn with_default_border(mut self) -> Self {
         self.default_details.border = Some(BorderSymbols::default());
         self
     }
 
     /// Menu builder with new value for border value
     #[must_use]
     pub fn with_border(
         mut self,
         top_right: char,
         top_left: char,
         bottom_right: char,
         bottom_left: char,
         horizontal: char,
         vertical: char,
     ) -> Self {
         self.default_details.border = Some(BorderSymbols {
             top_right,
             top_left,
             bottom_right,
             bottom_left,
             horizontal,
             vertical,
         });
         self
     }
 
     /// Menu builder with new value for cursor offset value
     #[must_use]
     pub fn with_cursor_offset(mut self, cursor_offset: i16) -> Self {
         self.default_details.cursor_offset = cursor_offset;
         self
     }
 
     /// Menu builder with marker
     #[must_use]
     pub fn with_marker(mut self, marker: String) -> Self {
         self.marker = marker;
         self
     }
 
     /// Menu builder with new only buffer difference
     #[must_use]
     pub fn with_only_buffer_difference(mut self, only_buffer_difference: bool) -> Self {
         self.only_buffer_difference = only_buffer_difference;
         self
     }
 
     /// Menu builder with new description mode
     #[must_use]
     pub fn with_description_mode(mut self, description_mode: DescriptionMode) -> Self {
         self.default_details.description_mode = description_mode;
         self
     }
 
     /// Menu builder with new min description width
     #[must_use]
     pub fn with_min_description_width(mut self, min_description_width: u16) -> Self {
         self.default_details.min_description_width = min_description_width;
         self
     }
 
     /// Menu builder with new max description width
     #[must_use]
     pub fn with_max_description_width(mut self, max_description_width: u16) -> Self {
         self.default_details.max_description_width = max_description_width;
         self
     }
 
     /// Menu builder with new max description height
     #[must_use]
     pub fn with_max_description_height(mut self, max_description_height: u16) -> Self {
         self.default_details.max_description_height = max_description_height;
         self
     }
 
     /// Menu builder with new description offset
     #[must_use]
     pub fn with_description_offset(mut self, description_offset: u16) -> Self {
         self.default_details.description_offset = description_offset;
         self
     }
 }
 
 // Menu functionality
 impl IdeMenu {
     fn move_next(&mut self) {
         if self.selected < (self.values.len() as u16).saturating_sub(1) {
             self.selected += 1;
         } else {
             self.selected = 0;
         }
     }
 
     fn move_previous(&mut self) {
         if self.selected > 0 {
             self.selected -= 1;
         } else {
             self.selected = self.values.len().saturating_sub(1) as u16;
         }
     }
 
     fn index(&self) -> usize {
         self.selected as usize
@@ -334,343 +335,343 @@
     }
 
     /// Calculates how many rows the Menu will try to use (if available)
     fn get_rows(&self) -> u16 {
         let mut values = self.get_values().len() as u16;
 
         if values == 0 {
             // When the values are empty the no_records_msg is shown, taking 1 line
             return 1;
         }
 
         if self.default_details.border.is_some() {
             // top and bottom border take 1 line each
             values += 2;
         }
 
         let description_height = self
             .get_value()
             .and_then(|value| value.description)
             .map(|description| {
                 self.description_dims(
                     description,
                     self.working_details.description_width,
                     self.default_details.max_description_height,
                     0,
                 )
                 .1
             })
             .unwrap_or(0)
             .min(self.default_details.max_description_height);
 
         values.max(description_height)
     }
 
     /// Returns working details width
     fn get_width(&self) -> u16 {
         self.working_details.menu_width
     }
 
     fn reset_position(&mut self) {
         self.selected = 0;
     }
 
     fn no_records_msg(&self, use_ansi_coloring: bool) -> String {
         let msg = "NO RECORDS FOUND";
         if use_ansi_coloring {
             format!(
                 "{}{}{}",
                 self.color.selected_text_style.prefix(),
                 msg,
                 RESET
             )
         } else {
             msg.to_string()
         }
     }
 
     fn create_description(
         &self,
         description: String,
         use_ansi_coloring: bool,
         available_width: u16,
         available_height: u16,
         min_width: u16,
     ) -> Vec<String> {
         if description.is_empty() || available_width == 0 || available_height == 0 {
             return Vec::new();
         }
 
         let border_width = if self.default_details.border.is_some() {
             2
         } else {
             0
         };
 
         let content_width = available_width.saturating_sub(border_width);
         let content_height = available_height.saturating_sub(border_width);
 
         let mut description_lines = split_string(&description, content_width as usize);
 
         // panic!("{:?}", description_lines);
 
         if description_lines.len() > content_height as usize {
             description_lines.truncate(content_height as usize);
             truncate_string_list(&mut description_lines, "...");
         }
 
         let content_width = description_lines
             .iter()
             .map(|s| s.width())
             .max()
             .unwrap_or_default()
             .max(min_width.saturating_sub(border_width) as usize);
 
         // let needs_padding = description_lines.len() > 1
 
         if let Some(border) = &self.default_details.border {
             let horizontal_border = border.horizontal.to_string().repeat(content_width);
 
             for line in &mut description_lines {
                 let padding = " ".repeat(content_width.saturating_sub(line.width()));
 
                 if use_ansi_coloring {
                     *line = format!(
                         "{}{}{}{}{}{}",
                         border.vertical,
                         self.color.description_style.prefix(),
                         line,
                         padding,
                         RESET,
                         border.vertical
                     );
                 } else {
                     *line = format!("{}{}{}{}", border.vertical, line, padding, border.vertical);
                 }
             }
 
             description_lines.insert(
                 0,
                 format!(
                     "{}{}{}",
                     border.top_left, horizontal_border, border.top_right
                 ),
             );
             description_lines.push(format!(
                 "{}{}{}",
                 border.bottom_left, horizontal_border, border.bottom_right
             ));
         } else {
             for line in &mut description_lines {
                 let padding = " ".repeat(content_width.saturating_sub(line.width()));
 
                 if use_ansi_coloring {
                     *line = format!(
                         "{}{}{}{}",
                         self.color.description_style.prefix(),
                         line,
                         padding,
                         RESET
                     );
                 } else {
                     *line = format!("{}{}", line, padding);
                 }
             }
         }
 
         description_lines
     }
 
     /// Returns width and height of the description, including the border
     fn description_dims(
         &self,
         description: String,
         max_width: u16,
         max_height: u16,
         min_width: u16,
     ) -> (u16, u16) {
         // we will calculate the uncapped height, the real height
         // will be capped by the available lines
 
         let lines = self.create_description(description, false, max_width, max_height, min_width);
         let height = lines.len() as u16;
         let string = lines.first().cloned().unwrap_or_default();
         let width = string.width() as u16;
         (width, height)
     }
 
     fn create_value_string(
         &self,
         suggestion: &Suggestion,
         index: usize,
         use_ansi_coloring: bool,
         padding: usize,
     ) -> String {
         let border_width = if self.default_details.border.is_some() {
             2
         } else {
             0
         };
 
         let vertical_border = self
             .default_details
             .border
             .as_ref()
             .map(|border| border.vertical)
             .unwrap_or_default();
 
         let padding_right = (self.working_details.completion_width as usize)
             .saturating_sub(suggestion.value.chars().count() + border_width + padding);
 
         let max_string_width =
             (self.working_details.completion_width as usize).saturating_sub(border_width + padding);
 
         let string = if suggestion.value.chars().count() > max_string_width {
             let mut chars = suggestion
                 .value
                 .chars()
                 .take(max_string_width.saturating_sub(3))
                 .collect::<String>();
             chars.push_str("...");
             chars
         } else {
             suggestion.value.clone()
         };
 
         if use_ansi_coloring {
             if index == self.index() {
                 format!(
                     "{}{}{}{}{}{}{}",
                     vertical_border,
                     self.color.selected_text_style.prefix(),
                     " ".repeat(padding),
                     string,
                     " ".repeat(padding_right),
                     RESET,
                     vertical_border,
                 )
             } else {
                 format!(
                     "{}{}{}{}{}{}{}",
                     vertical_border,
                     self.color.text_style.prefix(),
                     " ".repeat(padding),
                     string,
                     " ".repeat(padding_right),
                     RESET,
                     vertical_border,
                 )
             }
         } else {
             let marker = if index == self.index() { ">" } else { "" };
 
             format!(
                 "{}{}{}{}{}{}",
                 vertical_border,
                 " ".repeat(padding),
                 marker,
                 string,
                 " ".repeat(padding_right),
                 vertical_border,
             )
         }
     }
 }
 
 impl Menu for IdeMenu {
     /// Menu name
     fn name(&self) -> &str {
         self.name.as_str()
     }
 
     /// Menu indicator
     fn indicator(&self) -> &str {
         self.marker.as_str()
     }
 
     /// Deactivates context menu
     fn is_active(&self) -> bool {
         self.active
     }
 
     /// The ide menu can to quick complete if there is only one element
     fn can_quick_complete(&self) -> bool {
         true
     }
 
     fn can_partially_complete(
         &mut self,
         values_updated: bool,
         editor: &mut Editor,
         completer: &mut dyn Completer,
     ) -> bool {
         // If the values were already updated (e.g. quick completions are true)
         // there is no need to update the values from the menu
         if !values_updated {
             self.update_values(editor, completer);
         }
 
         let values = self.get_values();
         if let (Some(Suggestion { value, span, .. }), Some(index)) = find_common_string(values) {
             let index = index.min(value.len());
             let matching = &value[0..index];
 
             // make sure that the partial completion does not overwrite user entered input
             let extends_input = matching.starts_with(&editor.get_buffer()[span.start..span.end]);
 
             if !matching.is_empty() && extends_input {
                 let mut line_buffer = editor.line_buffer().clone();
                 line_buffer.replace_range(span.start..span.end, matching);
 
                 let offset = if matching.len() < (span.end - span.start) {
                     line_buffer
                         .insertion_point()
                         .saturating_sub((span.end - span.start) - matching.len())
                 } else {
                     line_buffer.insertion_point() + matching.len() - (span.end - span.start)
                 };
 
                 line_buffer.set_insertion_point(offset);
                 editor.set_line_buffer(line_buffer, UndoBehavior::CreateUndoPoint);
 
                 // The values need to be updated because the spans need to be
                 // recalculated for accurate replacement in the string
                 self.update_values(editor, completer);
 
                 true
             } else {
                 false
             }
         } else {
             false
         }
     }
 
     /// Selects what type of event happened with the menu
     fn menu_event(&mut self, event: MenuEvent) {
         match &event {
             MenuEvent::Activate(_) => self.active = true,
             MenuEvent::Deactivate => {
                 self.active = false;
                 self.input = None;
             }
             _ => {}
         }
 
         self.event = Some(event);
     }
 
     /// Update menu values
     fn update_values(&mut self, editor: &mut Editor, completer: &mut dyn Completer) {
         self.values = if self.only_buffer_difference {
             if let Some(old_string) = &self.input {
                 let (start, input) = string_difference(editor.get_buffer(), old_string);
                 if !input.is_empty() {
                     completer.complete(input, start + input.len())
                 } else {
                     completer.complete("", editor.insertion_point())
                 }
             } else {
                 completer.complete("", editor.insertion_point())
             }
         } else {
             // If there is a new line character in the line buffer, the completer
@@ -690,157 +691,157 @@
 
     /// The working details for the menu changes based on the size of the lines
     /// collected from the completer
     fn update_working_details(
         &mut self,
         editor: &mut Editor,
         completer: &mut dyn Completer,
         painter: &Painter,
     ) {
         if let Some(event) = self.event.take() {
             // The working value for the menu are updated first before executing any of the
             match event {
                 MenuEvent::Activate(updated) => {
                     self.active = true;
                     self.reset_position();
 
                     self.input = if self.only_buffer_difference {
                         Some(editor.get_buffer().to_string())
                     } else {
                         None
                     };
 
                     if !updated {
                         self.update_values(editor, completer);
                     }
                 }
                 MenuEvent::Deactivate => self.active = false,
                 MenuEvent::Edit(updated) => {
                     self.reset_position();
 
                     if !updated {
                         self.update_values(editor, completer);
                     }
                 }
                 MenuEvent::NextElement | MenuEvent::MoveDown => self.move_next(),
                 MenuEvent::PreviousElement | MenuEvent::MoveUp => self.move_previous(),
                 MenuEvent::MoveLeft
                 | MenuEvent::MoveRight
                 | MenuEvent::PreviousPage
                 | MenuEvent::NextPage => {}
             }
 
             self.longest_suggestion = self.get_values().iter().fold(0, |prev, suggestion| {
                 if prev >= suggestion.value.len() {
                     prev
                 } else {
                     suggestion.value.len()
                 }
             });
 
             let terminal_width = painter.screen_width();
             let cursor_pos = self.working_details.cursor_col;
 
             let border_width = if self.default_details.border.is_some() {
                 2
             } else {
                 0
             };
 
             let description = self
                 .get_value()
                 .map(|v| {
                     if let Some(v) = v.description {
                         if v.is_empty() {
                             return None;
                         } else {
                             return Some(v);
                         }
                     }
                     None
                 })
                 .unwrap_or_default();
 
             let mut min_description_width = if description.is_some() {
                 self.default_details.min_description_width
             } else {
                 0
             };
 
             let completion_width = ((self.longest_suggestion.min(u16::MAX as usize) as u16)
                 + 2 * self.default_details.padding
                 + border_width)
                 .min(self.default_details.max_completion_width)
                 .max(self.default_details.min_completion_width)
                 .min(terminal_width.saturating_sub(min_description_width))
                 .max(3 + border_width); // Big enough to show "..."
 
             let available_description_width = terminal_width
                 .saturating_sub(completion_width)
                 .min(self.default_details.max_description_width)
                 .max(self.default_details.min_description_width)
                 .min(terminal_width.saturating_sub(completion_width));
 
             min_description_width = min_description_width.min(available_description_width);
 
             let description_width = if let Some(description) = description {
                 self.description_dims(
                     description,
                     available_description_width,
                     u16::MAX,
                     min_description_width,
                 )
                 .0
             } else {
                 0
             };
 
             let max_offset = terminal_width.saturating_sub(completion_width + description_width);
 
             let description_offset = self.default_details.description_offset.min(max_offset);
 
             self.working_details.completion_width = completion_width;
             self.working_details.description_width = description_width;
             self.working_details.description_offset = description_offset;
             self.working_details.menu_width =
                 completion_width + description_offset + description_width;
 
             let cursor_offset = self.default_details.cursor_offset;
 
             self.working_details.description_is_right = match self.default_details.description_mode
             {
                 DescriptionMode::Left => false,
                 DescriptionMode::Right => true,
                 DescriptionMode::PreferRight => {
                     // if there is enough space to the right of the cursor, the description is shown on the right
                     // otherwise it is shown on the left
                     let potential_right_distance = (terminal_width as i16)
                         .saturating_sub(
                             cursor_pos as i16
                                 + cursor_offset
                                 + description_offset as i16
                                 + completion_width as i16,
                         )
                         .max(0) as u16;
 
                     potential_right_distance >= description_width
                 }
             };
 
             let space_left = (if self.working_details.description_is_right {
                 cursor_pos as i16 + cursor_offset
             } else {
                 (cursor_pos as i16 + cursor_offset)
                     .saturating_sub(description_width as i16 + description_offset as i16)
             }
             .max(0) as u16)
                 .min(terminal_width.saturating_sub(self.get_width()));
 
             let space_right = terminal_width.saturating_sub(space_left + self.get_width());
 
             self.working_details.space_left = space_left;
             self.working_details.space_right = space_right;
         }
     }
 
     /// The buffer gets replaced in the Span location
     fn replace_in_buffer(&self, editor: &mut Editor) {
@@ -854,7 +855,7 @@
             let start = span.start.min(editor.line_buffer().len());
             let end = span.end.min(editor.line_buffer().len());
             if append_whitespace {
                 value.push(' ');
             }
             let mut line_buffer = editor.line_buffer().clone();
             line_buffer.replace_range(start..end, &value);
@@ -864,186 +865,186 @@
             offset = offset.saturating_sub(end.saturating_sub(start));
             line_buffer.set_insertion_point(offset);
             editor.set_line_buffer(line_buffer, UndoBehavior::CreateUndoPoint);
         }
     }
 
     /// Minimum rows that should be displayed by the menu
     fn min_rows(&self) -> u16 {
         self.get_rows()
     }
 
     fn get_values(&self) -> &[Suggestion] {
         &self.values
     }
 
     fn menu_required_lines(&self, _terminal_columns: u16) -> u16 {
         self.get_rows()
     }
 
     fn menu_string(&self, available_lines: u16, use_ansi_coloring: bool) -> String {
         if self.get_values().is_empty() {
             self.no_records_msg(use_ansi_coloring)
         } else {
             let border_width = if self.default_details.border.is_some() {
                 2
             } else {
                 0
             };
 
             let available_lines = available_lines.min(self.default_details.max_completion_height);
             // The skip values represent the number of lines that should be skipped
             // while printing the menu
             let skip_values = if self.selected >= available_lines.saturating_sub(border_width) {
                 let skip_lines = self
                     .selected
                     .saturating_sub(available_lines.saturating_sub(border_width))
                     + 1;
                 skip_lines as usize
             } else {
                 0
             };
 
             let available_values = available_lines.saturating_sub(border_width) as usize;
 
             let max_padding = self.working_details.completion_width.saturating_sub(
                 self.longest_suggestion.min(u16::MAX as usize) as u16 + border_width,
             ) / 2;
 
             let corrected_padding = self.default_details.padding.min(max_padding) as usize;
 
             let mut strings = self
                 .get_values()
                 .iter()
                 .skip(skip_values)
                 .take(available_values)
                 .enumerate()
                 .map(|(index, suggestion)| {
                     // Correcting the enumerate index based on the number of skipped values
 
                     let index = index + skip_values;
                     self.create_value_string(
                         suggestion,
                         index,
                         use_ansi_coloring,
                         corrected_padding,
                     )
                 })
                 .collect::<Vec<String>>();
 
             // Add top and bottom border
             if let Some(border) = &self.default_details.border {
                 let inner_width = self.working_details.completion_width.saturating_sub(2) as usize;
 
                 strings.insert(
                     0,
                     format!(
                         "{}{}{}",
                         border.top_left,
                         border.horizontal.to_string().repeat(inner_width),
                         border.top_right,
                     ),
                 );
 
                 strings.push(format!(
                     "{}{}{}",
                     border.bottom_left,
                     border.horizontal.to_string().repeat(inner_width),
                     border.bottom_right,
                 ));
             }
 
             let decsription_height =
                 available_lines.min(self.default_details.max_description_height);
             let description_lines = self
                 .get_value()
                 .and_then(|value| value.clone().description)
                 .map(|description| {
                     self.create_description(
                         description,
                         use_ansi_coloring,
                         self.working_details.description_width,
                         decsription_height,
                         self.working_details.description_width, // the width has already been calculated
                     )
                 })
                 .unwrap_or_default();
 
             let distance_left = &" ".repeat(self.working_details.space_left as usize);
 
             // Horizontally join the description lines with the suggestion lines
             if self.working_details.description_is_right {
                 for (idx, pair) in strings
                     .clone()
                     .iter()
                     .zip_longest(description_lines.iter())
                     .enumerate()
                 {
                     match pair {
                         Both(_suggestion_line, description_line) => {
                             strings[idx] = format!(
                                 "{}{}{}{}",
                                 distance_left,
                                 strings[idx],
                                 " ".repeat(self.working_details.description_offset as usize),
                                 description_line,
                             )
                         }
                         Left(suggestion_line) => {
                             strings[idx] = format!("{}{}", distance_left, suggestion_line);
                         }
                         Right(description_line) => strings.push(format!(
                             "{}{}",
                             " ".repeat(
                                 (self.working_details.completion_width
                                     + self.working_details.description_offset)
                                     as usize
                             ) + distance_left,
                             description_line,
                         )),
                     }
                 }
             } else {
                 for (idx, pair) in strings
                     .clone()
                     .iter()
                     .zip_longest(description_lines.iter())
                     .enumerate()
                 {
                     match pair {
                         Both(suggestion_line, description_line) => {
                             strings[idx] = format!(
                                 "{}{}{}{}",
                                 distance_left,
                                 description_line,
                                 " ".repeat(self.working_details.description_offset as usize),
                                 suggestion_line,
                             )
                         }
                         Left(suggestion_line) => {
                             strings[idx] = format!(
                                 "{}{}",
                                 " ".repeat(
                                     (self.working_details.description_width
                                         + self.working_details.description_offset)
                                         as usize
                                 ) + distance_left,
                                 suggestion_line,
                             );
                         }
                         Right(description_line) => {
                             strings.push(format!("{}{}", distance_left, description_line,))
                         }
                     }
                 }
             }
 
             strings.join("\r\n")
         }
     }
 
     fn set_cursor_pos(&mut self, pos: (u16, u16)) {
         self.working_details.cursor_col = pos.0;
     }
 }
 
 /// Split the input into strings that are at most `max_length` (in columns, not in chars) long
@@ -1459,7 +1460,7 @@
         // After replacing the editor, make sure insertion_point is at the right spot
         assert!(
             editor.is_cursor_at_buffer_end(),
             "cursor should be at the end after completion"
         );
     }
 }

src/menu/mod.rs

@@ -7,6 +7,7 @@
 use crate::History;
 use crate::{completion::history::HistoryCompleter, painting::Painter, Completer, Suggestion};
 pub use columnar_menu::ColumnarMenu;
+pub use ide_menu::DescriptionMode;
 pub use ide_menu::IdeMenu;
 pub use list_menu::ListMenu;
 use nu_ansi_term::{Color, Style};
@@ -317,7 +318,7 @@
         self.as_ref().get_values()
     }
 
     fn set_cursor_pos(&mut self, pos: (u16, u16)) {
         self.as_mut().set_cursor_pos(pos);
     }
 }

src/painting/prompt_lines.rs

@@ -92,16 +92,28 @@ impl<'prompt> PromptLines<'prompt> {
     /// The height is relative to the prompt
     pub(crate) fn cursor_pos(&self, terminal_columns: u16) -> (u16, u16) {
         // If we have a multiline prompt (e.g starship), we expect the cursor to be on the last line
-        let prompt_str = self.prompt_str_left.lines().last().unwrap_or_default();
-        let prompt_width = line_width(&format!("{}{}", prompt_str, self.prompt_indicator));
-        let buffer_width = line_width(&self.before_cursor);
+        let prompt_str = format!("{}{}", self.prompt_str_left, self.prompt_indicator);
+        // The Cursor position will be relative to this
+        let last_prompt_str = prompt_str.lines().last().unwrap_or_default();
 
-        let total_width = prompt_width + buffer_width;
+        let is_multiline = self.before_cursor.contains('\n');
+        let buffer_width = line_width(self.before_cursor.lines().last().unwrap_or_default());
+
+        let total_width = if is_multiline {
+            // The buffer already contains the multiline prompt
+            buffer_width
+        } else {
+            buffer_width + line_width(last_prompt_str)
+        };
+
+        let buffer_width_prompt = format!("{}{}", last_prompt_str, self.before_cursor);
+
+        let cursor_y = (estimate_required_lines(&buffer_width_prompt, terminal_columns) as u16)
+            .saturating_sub(1); // 0 based
 
         let cursor_x = (total_width % terminal_columns as usize) as u16;
-        let cursor_y = (total_width / terminal_columns as usize) as u16;
 
-        (cursor_x, cursor_y)
+        (cursor_x, cursor_y as u16)
     }
 
     /// Total lines that the prompt uses considering that it may wrap the screen
@@ -154,3 +166,90 @@ impl<'prompt> PromptLines<'prompt> {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use pretty_assertions::assert_eq;
+    use rstest::rstest;
+
+    #[rstest]
+    #[case(
+        "~/path/",
+        "❯ ",
+        "",
+        100,
+        (9, 0)
+    )]
+    #[case(
+        "~/longer/path/\n",
+        "❯ ",
+        "test",
+        100,
+        (6, 0)
+    )]
+    #[case(
+        "~/longer/path/",
+        "\n❯ ",
+        "test",
+        100,
+        (6, 0)
+    )]
+    #[case(
+        "~/longer/path/\n",
+        "\n❯ ",
+        "test",
+        100,
+        (6, 0)
+    )]
+    #[case(
+        "~/path/",
+        "❯ ",
+        "very long input that does not fit in a single line",
+        40,
+        (19, 1)
+    )]
+    #[case(
+        "~/path/\n",
+        "\n❯\n ",
+        "very long input that does not fit in a single line",
+        10,
+        (1, 5)
+    )]
+    #[case(
+        "~/path/",
+        "❯ ",
+        "this is a text that contains newlines\n::: and a multiline prompt",
+        40,
+        (26, 2)
+    )]
+    #[case(
+        "~/path/",
+        "❯ ",
+        "this is a text that contains newlines\n::: and very loooooooooooooooong text that wraps",
+        40,
+        (8, 3)
+    )]
+
+    fn test_cursor_pos(
+        #[case] prompt_str_left: &str,
+        #[case] prompt_indicator: &str,
+        #[case] before_cursor: &str,
+        #[case] terminal_columns: u16,
+        #[case] expected: (u16, u16),
+    ) {
+        let prompt_lines = PromptLines {
+            prompt_str_left: Cow::Borrowed(prompt_str_left),
+            prompt_str_right: Cow::Borrowed(""),
+            prompt_indicator: Cow::Borrowed(prompt_indicator),
+            before_cursor: Cow::Borrowed(before_cursor),
+            after_cursor: Cow::Borrowed(""),
+            hint: Cow::Borrowed(""),
+            right_prompt_on_last_line: false,
+        };
+
+        let pos = prompt_lines.cursor_pos(terminal_columns);
+
+        assert_eq!(pos, expected);
+    }
+}