tenseleyflow/fackr / 196304d

+/target

+Cargo.lock

+*.swp

+*.swo

+*~

+.DS_Store

+/planning/

+[package]

+name = "fac"

+version = "0.1.0"

+edition = "2021"

+description = "Terminal text editor"

+authors = ["Matthew Forrester Wolffe"]

+

+[dependencies]

+# Terminal

+crossterm = "0.28"

+

+# Text handling

+ropey = "1.6"

+unicode-segmentation = "1.10"

+unicode-width = "0.1"

+

+# Error handling

+thiserror = "1"

+anyhow = "1"

+

+[profile.release]

+opt-level = 3

+lto = true

+mod rope;

+

+pub use rope::Buffer;

+use anyhow::Result;

+use ropey::Rope;

+use std::fs::File;

+use std::io::{BufReader, BufWriter};

+use std::path::Path;

+

+/// Text buffer using rope data structure for efficient editing

+#[derive(Debug)]

+pub struct Buffer {

+    text: Rope,

+    pub modified: bool,

+}

+

+impl Default for Buffer {

+    fn default() -> Self {

+        Self::new()

+    }

+}

+

+impl Buffer {

+    pub fn new() -> Self {

+        Self {

+            text: Rope::new(),

+            modified: false,

+        }

+    }

+

+    pub fn from_str(s: &str) -> Self {

+        Self {

+            text: Rope::from_str(s),

+            modified: false,

+        }

+    }

+

+    pub fn load<P: AsRef<Path>>(path: P) -> Result<Self> {

+        let file = File::open(path)?;

+        let reader = BufReader::new(file);

+        let text = Rope::from_reader(reader)?;

+        Ok(Self {

+            text,

+            modified: false,

+        })

+    }

+

+    pub fn save<P: AsRef<Path>>(&mut self, path: P) -> Result<()> {

+        let file = File::create(path)?;

+        let writer = BufWriter::new(file);

+        self.text.write_to(writer)?;

+        self.modified = false;

+        Ok(())

+    }

+

+    /// Insert text at character index

+    pub fn insert(&mut self, char_idx: usize, text: &str) {

+        let idx = char_idx.min(self.text.len_chars());

+        self.text.insert(idx, text);

+        self.modified = true;

+    }

+

+    /// Delete characters in range [start, end)

+    pub fn delete(&mut self, start: usize, end: usize) {

+        let start = start.min(self.text.len_chars());

+        let end = end.min(self.text.len_chars());

+        if start < end {

+            self.text.remove(start..end);

+            self.modified = true;

+        }

+    }

+

+    /// Get total line count

+    pub fn line_count(&self) -> usize {

+        self.text.len_lines()

+    }

+

+    /// Get total character count

+    pub fn char_count(&self) -> usize {

+        self.text.len_chars()

+    }

+

+    /// Get a line's content (0-indexed)

+    pub fn line(&self, line_idx: usize) -> Option<ropey::RopeSlice> {

+        if line_idx < self.text.len_lines() {

+            Some(self.text.line(line_idx))

+        } else {

+            None

+        }

+    }

+

+    /// Get line as String (without trailing newline)

+    pub fn line_str(&self, line_idx: usize) -> Option<String> {

+        self.line(line_idx).map(|l| {

+            let s: String = l.chars().collect();

+            s.trim_end_matches('\n').to_string()

+        })

+    }

+

+    /// Get character count for a line (excluding newline)

+    pub fn line_len(&self, line_idx: usize) -> usize {

+        self.line(line_idx)

+            .map(|l| {

+                let len = l.len_chars();

+                // Subtract 1 for newline if not last line

+                if line_idx + 1 < self.text.len_lines() && len > 0 {

+                    len - 1

+                } else {

+                    len

+                }

+            })

+            .unwrap_or(0)

+    }

+

+    /// Convert (line, col) to absolute char index

+    pub fn line_col_to_char(&self, line: usize, col: usize) -> usize {

+        if line >= self.text.len_lines() {

+            return self.text.len_chars();

+        }

+        let line_start = self.text.line_to_char(line);

+        let line_len = self.line_len(line);

+        line_start + col.min(line_len)

+    }

+

+    /// Convert absolute char index to (line, col)

+    pub fn char_to_line_col(&self, char_idx: usize) -> (usize, usize) {

+        let idx = char_idx.min(self.text.len_chars());

+        let line = self.text.char_to_line(idx);

+        let line_start = self.text.line_to_char(line);

+        let col = idx - line_start;

+        (line, col)

+    }

+

+    /// Get character at position

+    pub fn char_at(&self, char_idx: usize) -> Option<char> {

+        if char_idx < self.text.len_chars() {

+            Some(self.text.char(char_idx))

+        } else {

+            None

+        }

+    }

+

+    /// Check if buffer is empty

+    pub fn is_empty(&self) -> bool {

+        self.text.len_chars() == 0

+    }

+

+    /// Get rope slice for a range

+    pub fn slice(&self, start: usize, end: usize) -> ropey::RopeSlice {

+        let start = start.min(self.text.len_chars());

+        let end = end.min(self.text.len_chars());

+        self.text.slice(start..end)

+    }

+}

+

+#[cfg(test)]

+mod tests {

+    use super::*;

+

+    #[test]

+    fn test_new_buffer() {

+        let buf = Buffer::new();

+        assert_eq!(buf.line_count(), 1);

+        assert_eq!(buf.char_count(), 0);

+    }

+

+    #[test]

+    fn test_insert() {

+        let mut buf = Buffer::new();

+        buf.insert(0, "Hello");

+        assert_eq!(buf.line_str(0), Some("Hello".to_string()));

+        assert!(buf.modified);

+    }

+

+    #[test]

+    fn test_multiline() {

+        let buf = Buffer::from_str("Hello\nWorld\n");

+        assert_eq!(buf.line_count(), 3);

+        assert_eq!(buf.line_str(0), Some("Hello".to_string()));

+        assert_eq!(buf.line_str(1), Some("World".to_string()));

+    }

+

+    #[test]

+    fn test_line_col_conversion() {

+        let buf = Buffer::from_str("Hello\nWorld");

+        assert_eq!(buf.line_col_to_char(0, 0), 0);

+        assert_eq!(buf.line_col_to_char(0, 5), 5);

+        assert_eq!(buf.line_col_to_char(1, 0), 6);

+        assert_eq!(buf.line_col_to_char(1, 3), 9);

+

+        assert_eq!(buf.char_to_line_col(0), (0, 0));

+        assert_eq!(buf.char_to_line_col(5), (0, 5));

+        assert_eq!(buf.char_to_line_col(6), (1, 0));

+    }

+

+    #[test]

+    fn test_delete() {

+        let mut buf = Buffer::from_str("Hello World");

+        buf.delete(5, 11);

+        assert_eq!(buf.line_str(0), Some("Hello".to_string()));

+    }

+}

+/// Cursor position (0-indexed line and column)

+#[derive(Debug, Clone, Copy, Default)]

+pub struct Cursor {

+    pub line: usize,

+    pub col: usize,

+    /// Desired column for vertical movement

+    pub desired_col: usize,

+}

+

+impl Cursor {

+    pub fn new() -> Self {

+        Self::default()

+    }

+

+    pub fn set(&mut self, line: usize, col: usize) {

+        self.line = line;

+        self.col = col;

+        self.desired_col = col;

+    }

+

+    pub fn move_to(&mut self, line: usize, col: usize) {

+        self.line = line;

+        self.col = col;

+        // Don't update desired_col for horizontal moves

+    }

+}

+mod cursor;

+mod state;

+

+pub use cursor::Cursor;

+pub use state::Editor;

+use anyhow::Result;

+use crossterm::event::{self, Event, KeyEvent};

+use std::path::PathBuf;

+use std::time::Duration;

+

+use crate::buffer::Buffer;

+use crate::input::{Key, Modifiers};

+use crate::render::Screen;

+

+use super::Cursor;

+

+/// Main editor state

+pub struct Editor {

+    buffer: Buffer,

+    cursor: Cursor,

+    viewport_line: usize,

+    screen: Screen,

+    filename: Option<PathBuf>,

+    running: bool,

+}

+

+impl Editor {

+    pub fn new() -> Result<Self> {

+        let mut screen = Screen::new()?;

+        screen.enter_raw_mode()?;

+

+        Ok(Self {

+            buffer: Buffer::new(),

+            cursor: Cursor::new(),

+            viewport_line: 0,

+            screen,

+            filename: None,

+            running: true,

+        })

+    }

+

+    pub fn open(&mut self, path: &str) -> Result<()> {

+        self.buffer = Buffer::load(path)?;

+        self.filename = Some(PathBuf::from(path));

+        self.cursor = Cursor::new();

+        self.viewport_line = 0;

+        Ok(())

+    }

+

+    pub fn run(&mut self) -> Result<()> {

+        while self.running {

+            self.screen.refresh_size()?;

+            self.render()?;

+

+            if event::poll(Duration::from_millis(100))? {

+                if let Event::Key(key_event) = event::read()? {

+                    self.handle_key(key_event)?;

+                }

+            }

+        }

+

+        self.screen.leave_raw_mode()?;

+        Ok(())

+    }

+

+    fn render(&mut self) -> Result<()> {

+        self.screen.render(

+            &self.buffer,

+            &self.cursor,

+            self.viewport_line,

+            self.filename.as_ref().and_then(|p| p.to_str()),

+        )

+    }

+

+    fn handle_key(&mut self, key_event: KeyEvent) -> Result<()> {

+        let (key, mods) = Key::from_crossterm(key_event);

+

+        match (&key, &mods) {

+            // Quit: Ctrl+Q

+            (Key::Char('q'), Modifiers { ctrl: true, .. }) => {

+                self.running = false;

+            }

+

+            // Save: Ctrl+S

+            (Key::Char('s'), Modifiers { ctrl: true, .. }) => {

+                self.save()?;

+            }

+

+            // Movement

+            (Key::Up, _) => self.move_up(),

+            (Key::Down, _) => self.move_down(),

+            (Key::Left, _) => self.move_left(),

+            (Key::Right, _) => self.move_right(),

+            (Key::Home, _) | (Key::Char('a'), Modifiers { ctrl: true, .. }) => self.move_home(),

+            (Key::End, _) | (Key::Char('e'), Modifiers { ctrl: true, .. }) => self.move_end(),

+            (Key::PageUp, _) => self.page_up(),

+            (Key::PageDown, _) => self.page_down(),

+

+            // Editing

+            (Key::Char(c), Modifiers { ctrl: false, alt: false, .. }) => {

+                self.insert_char(*c);

+            }

+            (Key::Enter, _) => self.insert_newline(),

+            (Key::Backspace, _) | (Key::Char('h'), Modifiers { ctrl: true, .. }) => {

+                self.delete_backward();

+            }

+            (Key::Delete, _) => self.delete_forward(),

+            (Key::Tab, Modifiers { shift: false, .. }) => self.insert_tab(),

+

+            _ => {}

+        }

+

+        self.scroll_to_cursor();

+        Ok(())

+    }

+

+    // === Movement ===

+

+    fn move_up(&mut self) {

+        if self.cursor.line > 0 {

+            self.cursor.line -= 1;

+            let line_len = self.buffer.line_len(self.cursor.line);

+            self.cursor.col = self.cursor.desired_col.min(line_len);

+        }

+    }

+

+    fn move_down(&mut self) {

+        if self.cursor.line + 1 < self.buffer.line_count() {

+            self.cursor.line += 1;

+            let line_len = self.buffer.line_len(self.cursor.line);

+            self.cursor.col = self.cursor.desired_col.min(line_len);

+        }

+    }

+

+    fn move_left(&mut self) {

+        if self.cursor.col > 0 {

+            self.cursor.col -= 1;

+            self.cursor.desired_col = self.cursor.col;

+        } else if self.cursor.line > 0 {

+            self.cursor.line -= 1;

+            self.cursor.col = self.buffer.line_len(self.cursor.line);

+            self.cursor.desired_col = self.cursor.col;

+        }

+    }

+

+    fn move_right(&mut self) {

+        let line_len = self.buffer.line_len(self.cursor.line);

+        if self.cursor.col < line_len {

+            self.cursor.col += 1;

+            self.cursor.desired_col = self.cursor.col;

+        } else if self.cursor.line + 1 < self.buffer.line_count() {

+            self.cursor.line += 1;

+            self.cursor.col = 0;

+            self.cursor.desired_col = 0;

+        }

+    }

+

+    fn move_home(&mut self) {

+        self.cursor.col = 0;

+        self.cursor.desired_col = 0;

+    }

+

+    fn move_end(&mut self) {

+        self.cursor.col = self.buffer.line_len(self.cursor.line);

+        self.cursor.desired_col = self.cursor.col;

+    }

+

+    fn page_up(&mut self) {

+        let page = self.screen.rows.saturating_sub(2) as usize;

+        self.cursor.line = self.cursor.line.saturating_sub(page);

+        let line_len = self.buffer.line_len(self.cursor.line);

+        self.cursor.col = self.cursor.desired_col.min(line_len);

+    }

+

+    fn page_down(&mut self) {

+        let page = self.screen.rows.saturating_sub(2) as usize;

+        self.cursor.line = (self.cursor.line + page).min(self.buffer.line_count().saturating_sub(1));

+        let line_len = self.buffer.line_len(self.cursor.line);

+        self.cursor.col = self.cursor.desired_col.min(line_len);

+    }

+

+    // === Editing ===

+

+    fn insert_char(&mut self, c: char) {

+        let idx = self.buffer.line_col_to_char(self.cursor.line, self.cursor.col);

+        self.buffer.insert(idx, &c.to_string());

+        self.cursor.col += 1;

+        self.cursor.desired_col = self.cursor.col;

+    }

+

+    fn insert_newline(&mut self) {

+        let idx = self.buffer.line_col_to_char(self.cursor.line, self.cursor.col);

+        self.buffer.insert(idx, "\n");

+        self.cursor.line += 1;

+        self.cursor.col = 0;

+        self.cursor.desired_col = 0;

+    }

+

+    fn insert_tab(&mut self) {

+        let idx = self.buffer.line_col_to_char(self.cursor.line, self.cursor.col);

+        self.buffer.insert(idx, "    ");

+        self.cursor.col += 4;

+        self.cursor.desired_col = self.cursor.col;

+    }

+

+    fn delete_backward(&mut self) {

+        if self.cursor.col > 0 {

+            let idx = self.buffer.line_col_to_char(self.cursor.line, self.cursor.col);

+            self.buffer.delete(idx - 1, idx);

+            self.cursor.col -= 1;

+            self.cursor.desired_col = self.cursor.col;

+        } else if self.cursor.line > 0 {

+            // Join with previous line

+            let prev_line_len = self.buffer.line_len(self.cursor.line - 1);

+            let idx = self.buffer.line_col_to_char(self.cursor.line, 0);

+            self.buffer.delete(idx - 1, idx); // Delete the newline

+            self.cursor.line -= 1;

+            self.cursor.col = prev_line_len;

+            self.cursor.desired_col = self.cursor.col;

+        }

+    }

+

+    fn delete_forward(&mut self) {

+        let line_len = self.buffer.line_len(self.cursor.line);

+        let idx = self.buffer.line_col_to_char(self.cursor.line, self.cursor.col);

+

+        if self.cursor.col < line_len {

+            self.buffer.delete(idx, idx + 1);

+        } else if self.cursor.line + 1 < self.buffer.line_count() {

+            // Delete newline, joining with next line

+            self.buffer.delete(idx, idx + 1);

+        }

+    }

+

+    // === Viewport ===

+

+    fn scroll_to_cursor(&mut self) {

+        let visible_rows = self.screen.rows.saturating_sub(1) as usize;

+

+        // Scroll up if cursor above viewport

+        if self.cursor.line < self.viewport_line {

+            self.viewport_line = self.cursor.line;

+        }

+

+        // Scroll down if cursor below viewport

+        if self.cursor.line >= self.viewport_line + visible_rows {

+            self.viewport_line = self.cursor.line - visible_rows + 1;

+        }

+    }

+

+    // === File operations ===

+

+    fn save(&mut self) -> Result<()> {

+        if let Some(ref path) = self.filename {

+            self.buffer.save(path)?;

+        }

+        Ok(())

+    }

+}

+

+impl Drop for Editor {

+    fn drop(&mut self) {

+        let _ = self.screen.leave_raw_mode();

+    }

+}

+use crossterm::event::{KeyCode, KeyEvent, KeyModifiers};

+

+/// Key modifiers

+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]

+pub struct Modifiers {

+    pub ctrl: bool,

+    pub alt: bool,

+    pub shift: bool,

+}

+

+impl From<KeyModifiers> for Modifiers {

+    fn from(m: KeyModifiers) -> Self {

+        Self {

+            ctrl: m.contains(KeyModifiers::CONTROL),

+            alt: m.contains(KeyModifiers::ALT),

+            shift: m.contains(KeyModifiers::SHIFT),

+        }

+    }

+}

+

+/// Abstracted key input

+#[derive(Debug, Clone, PartialEq, Eq)]

+pub enum Key {

+    Char(char),

+    Backspace,

+    Delete,

+    Enter,

+    Tab,

+    Escape,

+    Up,

+    Down,

+    Left,

+    Right,

+    Home,

+    End,

+    PageUp,

+    PageDown,

+    F(u8),

+    Null,

+}

+

+impl Key {

+    pub fn from_crossterm(event: KeyEvent) -> (Self, Modifiers) {

+        let modifiers = Modifiers::from(event.modifiers);

+        let key = match event.code {

+            KeyCode::Char(c) => Key::Char(c),

+            KeyCode::Backspace => Key::Backspace,

+            KeyCode::Delete => Key::Delete,

+            KeyCode::Enter => Key::Enter,

+            KeyCode::Tab => Key::Tab,

+            KeyCode::Esc => Key::Escape,

+            KeyCode::Up => Key::Up,

+            KeyCode::Down => Key::Down,

+            KeyCode::Left => Key::Left,

+            KeyCode::Right => Key::Right,

+            KeyCode::Home => Key::Home,

+            KeyCode::End => Key::End,

+            KeyCode::PageUp => Key::PageUp,

+            KeyCode::PageDown => Key::PageDown,

+            KeyCode::F(n) => Key::F(n),

+            KeyCode::Null => Key::Null,

+            _ => Key::Null,

+        };

+        (key, modifiers)

+    }

+}

+mod key;

+

+pub use key::{Key, Modifiers};

+mod buffer;

+mod editor;

+mod input;

+mod render;

+mod util;

+

+use anyhow::Result;

+use editor::Editor;

+use std::env;

+

+fn main() -> Result<()> {

+    let args: Vec<String> = env::args().collect();

+    let filename = args.get(1).map(|s| s.as_str());

+

+    let mut editor = Editor::new()?;

+

+    if let Some(path) = filename {

+        editor.open(path)?;

+    }

+

+    editor.run()

+}

+mod screen;

+

+pub use screen::Screen;

+use anyhow::Result;

+use crossterm::{

+    cursor::{Hide, MoveTo, Show},

+    execute,

+    style::{Color, Print, ResetColor, SetBackgroundColor, SetForegroundColor},

+    terminal::{self, Clear, ClearType, EnterAlternateScreen, LeaveAlternateScreen},

+};

+use std::io::{stdout, Stdout, Write};

+

+use crate::buffer::Buffer;

+use crate::editor::Cursor;

+

+/// Terminal screen renderer

+pub struct Screen {

+    stdout: Stdout,

+    pub rows: u16,

+    pub cols: u16,

+}

+

+impl Screen {

+    pub fn new() -> Result<Self> {

+        let (cols, rows) = terminal::size()?;

+        Ok(Self {

+            stdout: stdout(),

+            rows,

+            cols,

+        })

+    }

+

+    pub fn enter_raw_mode(&mut self) -> Result<()> {

+        terminal::enable_raw_mode()?;

+        execute!(self.stdout, EnterAlternateScreen, Hide)?;

+        Ok(())

+    }

+

+    pub fn leave_raw_mode(&mut self) -> Result<()> {

+        execute!(self.stdout, Show, LeaveAlternateScreen)?;

+        terminal::disable_raw_mode()?;

+        Ok(())

+    }

+

+    pub fn refresh_size(&mut self) -> Result<()> {

+        let (cols, rows) = terminal::size()?;

+        self.cols = cols;

+        self.rows = rows;

+        Ok(())

+    }

+

+    pub fn clear(&mut self) -> Result<()> {

+        execute!(self.stdout, Clear(ClearType::All))?;

+        Ok(())

+    }

+

+    /// Render the editor view

+    pub fn render(

+        &mut self,

+        buffer: &Buffer,

+        cursor: &Cursor,

+        viewport_line: usize,

+        filename: Option<&str>,

+    ) -> Result<()> {

+        let line_num_width = self.line_number_width(buffer.line_count());

+        let text_cols = self.cols as usize - line_num_width - 1; // -1 for separator

+

+        // Reserve 1 row for status bar

+        let text_rows = self.rows.saturating_sub(1) as usize;

+

+        // Draw text area

+        for row in 0..text_rows {

+            let line_idx = viewport_line + row;

+            execute!(self.stdout, MoveTo(0, row as u16))?;

+

+            if line_idx < buffer.line_count() {

+                // Line number

+                execute!(

+                    self.stdout,

+                    SetForegroundColor(Color::DarkGrey),

+                    Print(format!("{:>width$} ", line_idx + 1, width = line_num_width)),

+                    ResetColor

+                )?;

+

+                // Line content

+                if let Some(line) = buffer.line_str(line_idx) {

+                    let visible: String = line.chars().take(text_cols).collect();

+                    execute!(self.stdout, Print(&visible))?;

+                }

+            } else {

+                // Empty line indicator

+                execute!(

+                    self.stdout,

+                    SetForegroundColor(Color::DarkBlue),

+                    Print(format!("{:>width$} ", "~", width = line_num_width)),

+                    ResetColor

+                )?;

+            }

+

+            // Clear rest of line

+            execute!(self.stdout, Clear(ClearType::UntilNewLine))?;

+        }

+

+        // Status bar

+        self.render_status_bar(buffer, cursor, filename)?;

+

+        // Position cursor

+        let cursor_row = cursor.line.saturating_sub(viewport_line);

+        let cursor_col = line_num_width + 1 + cursor.col;

+        execute!(

+            self.stdout,

+            MoveTo(cursor_col as u16, cursor_row as u16),

+            Show

+        )?;

+

+        self.stdout.flush()?;

+        Ok(())

+    }

+

+    fn render_status_bar(

+        &mut self,

+        buffer: &Buffer,

+        cursor: &Cursor,

+        filename: Option<&str>,

+    ) -> Result<()> {

+        let status_row = self.rows.saturating_sub(1);

+        execute!(self.stdout, MoveTo(0, status_row))?;

+

+        // Status bar background

+        execute!(

+            self.stdout,

+            SetBackgroundColor(Color::DarkGrey),

+            SetForegroundColor(Color::White)

+        )?;

+

+        // Left side: filename + modified indicator

+        let name = filename.unwrap_or("[No Name]");

+        let modified = if buffer.modified { " [+]" } else { "" };

+        let left = format!(" {}{}", name, modified);

+

+        // Right side: position

+        let right = format!(" Ln {}, Col {} ", cursor.line + 1, cursor.col + 1);

+

+        // Pad middle

+        let padding = self.cols as usize - left.len() - right.len();

+        let middle = " ".repeat(padding.max(0));

+

+        execute!(

+            self.stdout,

+            Print(&left),

+            Print(&middle),

+            Print(&right),

+            ResetColor

+        )?;

+

+        Ok(())

+    }

+

+    fn line_number_width(&self, line_count: usize) -> usize {

+        let digits = if line_count == 0 {

+            1

+        } else {

+            (line_count as f64).log10().floor() as usize + 1

+        };

+        digits.max(3) // Minimum 3 characters

+    }

+}

+pub mod unicode;

+

+pub use unicode::*;

+use unicode_segmentation::UnicodeSegmentation;

+use unicode_width::UnicodeWidthStr;

+

+/// Get the display width of a string (handling wide chars like CJK)

+pub fn display_width(s: &str) -> usize {

+    UnicodeWidthStr::width(s)

+}

+

+/// Count grapheme clusters in a string

+pub fn grapheme_count(s: &str) -> usize {

+    s.graphemes(true).count()

+}

+

+/// Get the nth grapheme from a string

+pub fn nth_grapheme(s: &str, n: usize) -> Option<&str> {

+    s.graphemes(true).nth(n)

+}

+

+/// Convert a grapheme index to byte offset

+pub fn grapheme_to_byte_offset(s: &str, grapheme_idx: usize) -> usize {

+    s.graphemes(true)

+        .take(grapheme_idx)

+        .map(|g| g.len())

+        .sum()

+}

+

+/// Convert a byte offset to grapheme index

+pub fn byte_to_grapheme_offset(s: &str, byte_idx: usize) -> usize {

+    let mut count = 0;

+    let mut bytes = 0;

+    for g in s.graphemes(true) {

+        if bytes >= byte_idx {

+            break;

+        }

+        bytes += g.len();

+        count += 1;

+    }

+    count

+}