1use crate::TextEdit;
2use std::{
3 fmt,
4 ops::Range,
5 time::{Duration, Instant},
6};
7use unicode_segmentation::UnicodeSegmentation;
8use xrack_runtime::Node;
9
10const BULLET: &str = "•";
11
12#[derive(Clone)]
13pub(crate) struct PasswordEcho {
14 pub(crate) deadline: Instant,
15 text: Box<str>,
16 range: Range<usize>,
17}
18
19impl fmt::Debug for PasswordEcho {
20 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
21 f.debug_struct("PasswordEcho")
22 .field("deadline", &self.deadline)
23 .finish_non_exhaustive()
24 }
25}
26
27impl PasswordEcho {
28 pub(crate) fn new(
29 node: &Node,
30 text: &str,
31 typed: &str,
32 caret: usize,
33 now: Instant,
34 ) -> Option<Self> {
35 if !node.password_masked() || node.text_read_only() || typed.is_empty() {
36 return None;
37 }
38 let milliseconds = u64::try_from(node.int("password-mask-delay")?).ok()?;
39 if milliseconds == 0 {
40 return None;
41 }
42 let start = caret.checked_sub(typed.len())?;
43 if !text
46 .grapheme_indices(true)
47 .any(|(offset, grapheme)| offset == start && grapheme == typed)
48 {
49 return None;
50 }
51 Some(Self {
52 deadline: now.checked_add(Duration::from_millis(milliseconds))?,
53 text: text.into(),
54 range: start..caret,
55 })
56 }
57
58 pub(crate) fn matches(&self, node: &Node, text: &str) -> bool {
59 node.password_masked()
60 && !node.text_read_only()
61 && node
62 .int("password-mask-delay")
63 .is_some_and(|delay| delay > 0)
64 && self.text.as_ref() == text
65 }
66
67 fn visible_range(&self, node: &Node, text: &str) -> Option<Range<usize>> {
68 (Instant::now() < self.deadline && self.matches(node, text)).then(|| self.range.clone())
69 }
70}
71
72pub struct PasswordMask {
74 source_offsets: Vec<usize>,
75 display: String,
76 marker_len: usize,
77 revealed: Option<(usize, usize)>,
78}
79
80impl PasswordMask {
81 pub fn new(text: &str) -> Self {
82 Self::with_marker(text, BULLET)
83 }
84
85 pub fn for_node(node: &Node, text: &str) -> Self {
86 let Some(marker) = node.text("password-character").and_then(password_marker) else {
87 return Self::new(text);
88 };
89 Self::with_marker(text, marker)
90 }
91
92 #[doc(hidden)]
93 pub fn for_editor(node: &Node, text: &str, editor: Option<&TextEdit>) -> Self {
94 let mut mask = Self::for_node(node, text);
95 if let Some(range) = editor
96 .and_then(|editor| editor.password_echo.as_ref())
97 .and_then(|echo| echo.visible_range(node, text))
98 {
99 mask.reveal(text, range);
100 }
101 mask
102 }
103
104 fn reveal(&mut self, text: &str, range: Range<usize>) {
105 let index = self
106 .source_offsets
107 .partition_point(|&offset| offset < range.start);
108 let display_start = index * self.marker_len;
109 let mut display = self.display.clone();
110 display.replace_range(
111 display_start..display_start + self.marker_len,
112 &text[range.clone()],
113 );
114 self.revealed = Some((index, range.len()));
115 if !display
118 .grapheme_indices(true)
119 .map(|(offset, _)| offset)
120 .chain(std::iter::once(display.len()))
121 .eq((0..self.source_offsets.len()).map(|index| self.display_boundary(index)))
122 {
123 self.revealed = None;
124 return;
125 }
126 self.display = display;
127 }
128
129 fn with_marker(text: &str, marker: &str) -> Self {
130 let source_offsets: Vec<_> = text
131 .grapheme_indices(true)
132 .map(|(offset, _)| offset)
133 .chain(std::iter::once(text.len()))
134 .collect();
135 let display = marker.repeat(source_offsets.len() - 1);
136 Self {
137 source_offsets,
138 display,
139 marker_len: marker.len(),
140 revealed: None,
141 }
142 }
143
144 pub fn display(&self) -> &str {
145 &self.display
146 }
147
148 pub fn into_display(self) -> String {
149 self.display
150 }
151
152 pub fn display_offset(&self, source: usize) -> usize {
153 let index = self
154 .source_offsets
155 .partition_point(|&offset| offset <= source);
156 self.display_boundary(index.saturating_sub(1))
157 }
158
159 fn display_boundary(&self, index: usize) -> usize {
160 if let Some((slot, len)) = self.revealed
161 && index > slot
162 {
163 (index - 1) * self.marker_len + len
164 } else {
165 index * self.marker_len
166 }
167 }
168
169 pub fn source_offset(&self, display: usize) -> usize {
170 let index = if let Some((slot, len)) = self.revealed {
171 let start = slot * self.marker_len;
172 let end = start + len;
173 if display >= end {
174 slot + 1 + (display - end) / self.marker_len
175 } else {
176 (display / self.marker_len).min(slot)
177 }
178 } else {
179 display / self.marker_len
180 };
181 self.source_offsets[index.min(self.source_offsets.len() - 1)]
182 }
183}
184
185fn password_marker(value: &str) -> Option<&str> {
186 let marker = value.graphemes(true).next()?;
187 if marker.len() > 64 || marker.chars().any(|c| c.is_control() || c.is_whitespace()) {
189 return None;
190 }
191 let pair = marker.repeat(2);
193 (pair.graphemes(true).next() == Some(marker)).then_some(marker)
194}
195
196#[cfg(test)]
197mod tests {
198 use super::*;
199
200 #[test]
201 fn echo_uses_only_new_graphemes_and_remaps_all_offsets() {
202 let mut node = Node::new("LineEdit", None);
203 node.properties
204 .insert("input-type", xrack_runtime::InputType::Password.into());
205 node.properties
206 .insert("password-character", "*".to_owned().into());
207 node.properties
208 .insert("password-mask-delay", 1000_i64.into());
209 let text = "a👩💻b";
210 let end = text.len() - 1;
211 let now = Instant::now();
212 let mut editor = TextEdit::at_end(text);
213 editor.password_echo = PasswordEcho::new(&node, text, "👩💻", end, now);
214 assert_eq!(
215 editor.password_echo.as_ref().unwrap().deadline,
216 now + Duration::from_secs(1)
217 );
218 let mask = PasswordMask::for_editor(&node, text, Some(&editor));
219 assert_eq!(mask.display(), "*👩💻*");
220 assert_eq!(mask.source_offset(2), 1);
221 assert_eq!(mask.source_offset(end), end);
222 assert_eq!(mask.display_offset(end), end);
223 assert_eq!(mask.source_offset(mask.display().len()), text.len());
224 assert_eq!(PasswordMask::for_node(&node, text).display(), "***");
225 assert_eq!(
226 PasswordMask::for_editor(&node, "x👩💻b", Some(&editor)).display(),
227 "***"
228 );
229 assert!(PasswordEcho::new(&node, "e\u{301}", "\u{301}", 3, now).is_none());
230 assert!(PasswordEcho::new(&node, "ab", "ab", 2, now).is_none());
231 node.properties.insert("password-mask-delay", 0_i64.into());
232 assert_eq!(
233 PasswordMask::for_editor(&node, text, Some(&editor)).display(),
234 "***"
235 );
236 }
237
238 #[test]
239 fn marker_preserves_utf8_grapheme_boundaries_and_has_a_safe_fallback() {
240 let mut node = Node::new("LineEdit", None);
241 let source = "e\u{301}👩💻";
242 for (configured, marker) in [
243 ("*unused", "*"),
244 ("🔒", "🔒"),
245 ("🇨🇳", "🇨🇳"),
246 ("", "•"),
247 ("\n", "•"),
248 ("🇨", "•"),
249 ("\u{301}", "•"),
250 ] {
251 node.properties
252 .insert("password-character", configured.to_owned().into());
253 let mask = PasswordMask::for_node(&node, source);
254 assert_eq!(mask.display(), marker.repeat(2));
255 assert_eq!(mask.display_offset(1), 0);
256 assert_eq!(mask.display_offset(3), marker.len());
257 assert_eq!(mask.source_offset(marker.len()), 3);
258 assert_eq!(mask.source_offset(mask.display().len()), source.len());
259 }
260 }
261}