bubbletea-widgets 0.1.12

A collection of reusable TUI components for building terminal applications with bubbletea-rs
Documentation 
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
134
135
136
137
138
139
140
141
142
143
144
145

//! Cursor movement and text deletion methods.

use super::model::Model;
use super::types::EchoMode;

impl Model {
    /// Delete all text before the cursor
    pub(super) fn delete_before_cursor(&mut self) {
        if self.pos < self.value.len() {
            self.value.drain(..self.pos);
        } else {
            self.value.clear();
        }
        self.err = self.validate_runes(&self.value);
        self.offset = 0;
        self.set_cursor(0);
    }

    /// Delete all text after the cursor
    pub(super) fn delete_after_cursor(&mut self) {
        self.value.truncate(self.pos);
        self.err = self.validate_runes(&self.value);
        self.set_cursor(self.value.len());
    }

    /// Delete the word before the cursor
    pub(super) fn delete_word_backward(&mut self) {
        if self.pos == 0 || self.value.is_empty() {
            return;
        }

        if self.echo_mode != EchoMode::EchoNormal {
            self.delete_before_cursor();
            return;
        }

        let old_pos = self.pos;

        // Move to start of current word
        if self.pos > 0 {
            self.pos -= 1;

            // Skip whitespace
            while self.pos > 0 && self.value[self.pos].is_whitespace() {
                self.pos -= 1;
            }

            // Skip non-whitespace
            while self.pos > 0 && !self.value[self.pos].is_whitespace() {
                self.pos -= 1;
            }

            if self.pos > 0 {
                self.pos += 1; // Keep one space
            }
        }

        self.value.drain(self.pos..old_pos);
        self.err = self.validate_runes(&self.value);
    }

    /// Delete the word after the cursor
    pub(super) fn delete_word_forward(&mut self) {
        if self.pos >= self.value.len() || self.value.is_empty() {
            return;
        }

        if self.echo_mode != EchoMode::EchoNormal {
            self.delete_after_cursor();
            return;
        }

        let old_pos = self.pos;
        let mut end_pos = self.pos;

        // Skip whitespace
        while end_pos < self.value.len() && self.value[end_pos].is_whitespace() {
            end_pos += 1;
        }

        // Skip non-whitespace
        while end_pos < self.value.len() && !self.value[end_pos].is_whitespace() {
            end_pos += 1;
        }

        self.value.drain(old_pos..end_pos);
        self.err = self.validate_runes(&self.value);
        self.set_cursor(old_pos);
    }

    /// Move cursor backward by one word
    pub(super) fn word_backward(&mut self) {
        if self.pos == 0 || self.value.is_empty() {
            return;
        }

        if self.echo_mode != EchoMode::EchoNormal {
            self.cursor_start();
            return;
        }

        let mut i = self.pos;
        if i > 0 {
            i -= 1;

            // Skip whitespace
            while i > 0 && self.value[i].is_whitespace() {
                self.set_cursor(self.pos - 1);
                i -= 1;
            }

            // Skip non-whitespace
            while i > 0 && !self.value[i].is_whitespace() {
                self.set_cursor(self.pos - 1);
                i -= 1;
            }
        }
    }

    /// Move cursor forward by one word
    pub(super) fn word_forward(&mut self) {
        if self.pos >= self.value.len() || self.value.is_empty() {
            return;
        }

        if self.echo_mode != EchoMode::EchoNormal {
            self.cursor_end();
            return;
        }

        let mut i = self.pos;

        // Skip whitespace
        while i < self.value.len() && self.value[i].is_whitespace() {
            self.set_cursor(self.pos + 1);
            i += 1;
        }

        // Skip non-whitespace
        while i < self.value.len() && !self.value[i].is_whitespace() {
            self.set_cursor(self.pos + 1);
            i += 1;
        }
    }
}