use std::ops::Range;
use super::{MarkPresence, SelectionStyle, SpanStyle, StyledSpan};
use crate::node::text_selection::{clamp_to_char_boundary, previous_char_boundary};
pub(crate) fn normalize(text: &str, spans: Vec<StyledSpan>) -> Vec<StyledSpan> {
let mut out: Vec<StyledSpan> = Vec::new();
let in_order = spans.windows(2).all(|pair| pair[0].range.end <= pair[1].range.start);
for span in spans {
let start = clamp_to_char_boundary(text, span.range.start);
let end = clamp_to_char_boundary(text, span.range.end);
if start >= end || span.style.is_plain() {
continue;
}
if in_order {
out.push(StyledSpan::new(start..end, span.style));
} else {
out = overwrite(out, start..end, span.style);
}
}
merge(out)
}
pub(crate) fn splice(spans: &[StyledSpan], range: Range<usize>, inserted: usize, style: &SpanStyle) -> Vec<StyledSpan> {
let removed = range.end - range.start;
let shift = |offset: usize| offset - removed + inserted;
let mut out = Vec::with_capacity(spans.len() + 1);
for span in spans {
if span.range.start < range.start {
out.push(StyledSpan::new(
span.range.start..span.range.end.min(range.start),
span.style.clone(),
));
}
if span.range.end > range.end {
let start = span.range.start.max(range.end);
out.push(StyledSpan::new(shift(start)..shift(span.range.end), span.style.clone()));
}
}
if inserted > 0 && !style.is_plain() {
out.push(StyledSpan::new(range.start..range.start + inserted, style.clone()));
}
out.sort_by_key(|span| span.range.start);
merge(out)
}
pub(crate) fn restyle(
spans: &[StyledSpan],
len: usize,
range: Range<usize>,
change: impl Fn(&mut SpanStyle),
) -> Vec<StyledSpan> {
let mut out = Vec::with_capacity(spans.len() + 2);
for (run, style) in runs(spans, len) {
let inside = run.start.max(range.start)..run.end.min(range.end);
if inside.is_empty() {
out.push(StyledSpan::new(run, style));
continue;
}
out.push(StyledSpan::new(run.start..inside.start, style.clone()));
let mut changed = style.clone();
change(&mut changed);
out.push(StyledSpan::new(inside.clone(), changed));
out.push(StyledSpan::new(inside.end..run.end, style));
}
merge(out)
}
pub(crate) fn style_at(spans: &[StyledSpan], offset: usize) -> SpanStyle {
let index = spans.partition_point(|span| span.range.end <= offset);
spans
.get(index)
.filter(|span| span.range.start <= offset)
.map(|span| span.style.clone())
.unwrap_or_default()
}
pub(crate) fn slice(spans: &[StyledSpan], range: Range<usize>) -> Vec<StyledSpan> {
spans
.iter()
.filter_map(|span| {
let start = span.range.start.max(range.start);
let end = span.range.end.min(range.end);
(start < end).then(|| StyledSpan::new(start - range.start..end - range.start, span.style.clone()))
})
.collect()
}
pub(crate) fn summarize(spans: &[StyledSpan], len: usize, range: Range<usize>) -> SelectionStyle {
let mut counts = [0usize; 5];
let mut total = 0;
let mut links = Vec::new();
for (run, style) in runs(spans, len) {
if run.start.max(range.start) >= run.end.min(range.end) {
continue;
}
total += 1;
for (count, mark) in counts.iter_mut().zip(super::TextMark::ALL) {
*count += usize::from(style.has(mark));
}
links.push(style.link);
}
let presence = |count: usize| match count {
0 => MarkPresence::None,
count if count == total => MarkPresence::All,
_ => MarkPresence::Some,
};
let common = links
.first()
.cloned()
.flatten()
.filter(|first| links.iter().all(|link| link.as_deref() == Some(first.as_ref())));
SelectionStyle {
bold: presence(counts[0]),
italic: presence(counts[1]),
code: presence(counts[2]),
strikethrough: presence(counts[3]),
underline: presence(counts[4]),
has_link: links.iter().any(Option::is_some),
link: common,
}
}
pub(crate) fn insertion_style(text: &str, spans: &[StyledSpan], start: usize, end: usize) -> SpanStyle {
if start < end {
return style_at(spans, start);
}
let before = previous_char_boundary(text, start);
let line_start = start == 0 || text[before..start].contains(['\n', '\r']);
if line_start {
let after = text[start..].chars().next().filter(|ch| !matches!(ch, '\n' | '\r'));
return after.map_or_else(SpanStyle::default, |_| SpanStyle {
link: None,
..style_at(spans, start)
});
}
let mut style = style_at(spans, before);
if style.link.is_some() && style_at(spans, start).link != style.link {
style.link = None;
}
style
}
pub(super) fn runs(spans: &[StyledSpan], len: usize) -> Vec<(Range<usize>, SpanStyle)> {
let mut out = Vec::with_capacity(spans.len() * 2 + 1);
let mut at = 0;
for span in spans {
if span.range.start > at {
out.push((at..span.range.start, SpanStyle::default()));
}
out.push((span.range.clone(), span.style.clone()));
at = span.range.end;
}
if at < len {
out.push((at..len, SpanStyle::default()));
}
out
}
fn overwrite(spans: Vec<StyledSpan>, range: Range<usize>, style: SpanStyle) -> Vec<StyledSpan> {
let mut out = Vec::with_capacity(spans.len() + 2);
for span in spans {
if span.range.start < range.start {
out.push(StyledSpan::new(
span.range.start..span.range.end.min(range.start),
span.style.clone(),
));
}
if span.range.end > range.end {
out.push(StyledSpan::new(
span.range.start.max(range.end)..span.range.end,
span.style,
));
}
}
out.push(StyledSpan::new(range, style));
out.sort_by_key(|span| span.range.start);
out
}
fn merge(spans: Vec<StyledSpan>) -> Vec<StyledSpan> {
let mut out: Vec<StyledSpan> = Vec::with_capacity(spans.len());
for span in spans {
if span.range.is_empty() || span.style.is_plain() {
continue;
}
if let Some(last) = out.last_mut()
&& last.range.end == span.range.start
&& last.style == span.style
{
last.range.end = span.range.end;
continue;
}
out.push(span);
}
out
}
#[cfg(test)]
#[path = "../../../tests/input/text_input/styled_ops.rs"]
mod tests;