From 768cca205b4336238e5ba46465d948f0be334461 Mon Sep 17 00:00:00 2001 From: Kevin Longe <273747162+kvlonge@users.noreply.github.com> Date: Sun, 15 Nov 2026 14:59:19 +0000 Subject: [PATCH 01/16] wip: shared screen renderers for the sqb dev screen Phase lines, tree groups, the ready card, event lines, the hotkey bar, frame rules, plain lines and in-place redraw, with snapshot tests at 80 and 120 columns and a no-wrap check at every width. Not yet wired into sqb dev. --- .../sqlbuild-core/src/cli_text/constants.rs | 1 + crates/sqlbuild-core/src/cli_text/models.rs | 8 +- crates/sqlbuild-core/src/lib.rs | 1 + .../src/screen_text/_helpers/mod.rs | 2 + .../src/screen_text/_helpers/phase_tones.rs | 47 ++ .../src/screen_text/_helpers/rows.rs | 148 +++++ .../src/screen_text/constants.rs | 44 ++ .../src/screen_text/main/format_elapsed.rs | 11 + .../src/screen_text/main/format_plain_line.rs | 15 + .../sqlbuild-core/src/screen_text/main/mod.rs | 10 + .../src/screen_text/main/redraw_rows.rs | 20 + .../src/screen_text/main/render_dev_header.rs | 23 + .../src/screen_text/main/render_event_line.rs | 54 ++ .../src/screen_text/main/render_frame_rule.rs | 20 + .../src/screen_text/main/render_hotkey_bar.rs | 19 + .../screen_text/main/render_phase_lines.rs | 53 ++ .../src/screen_text/main/render_ready_card.rs | 71 +++ .../src/screen_text/main/render_tree_group.rs | 67 +++ crates/sqlbuild-core/src/screen_text/mod.rs | 7 + .../sqlbuild-core/src/screen_text/models.rs | 163 ++++++ crates/sqlbuild-core/src/screen_text/tests.rs | 6 + .../src/screen_text/tests/helpers.rs | 172 ++++++ .../src/screen_text/tests/test_screen_text.rs | 536 ++++++++++++++++++ .../src/screen_text/tests/test_types.rs | 31 + 24 files changed, 1528 insertions(+), 1 deletion(-) create mode 100644 crates/sqlbuild-core/src/screen_text/_helpers/mod.rs create mode 100644 crates/sqlbuild-core/src/screen_text/_helpers/phase_tones.rs create mode 100644 crates/sqlbuild-core/src/screen_text/_helpers/rows.rs create mode 100644 crates/sqlbuild-core/src/screen_text/constants.rs create mode 100644 crates/sqlbuild-core/src/screen_text/main/format_elapsed.rs create mode 100644 crates/sqlbuild-core/src/screen_text/main/format_plain_line.rs create mode 100644 crates/sqlbuild-core/src/screen_text/main/mod.rs create mode 100644 crates/sqlbuild-core/src/screen_text/main/redraw_rows.rs create mode 100644 crates/sqlbuild-core/src/screen_text/main/render_dev_header.rs create mode 100644 crates/sqlbuild-core/src/screen_text/main/render_event_line.rs create mode 100644 crates/sqlbuild-core/src/screen_text/main/render_frame_rule.rs create mode 100644 crates/sqlbuild-core/src/screen_text/main/render_hotkey_bar.rs create mode 100644 crates/sqlbuild-core/src/screen_text/main/render_phase_lines.rs create mode 100644 crates/sqlbuild-core/src/screen_text/main/render_ready_card.rs create mode 100644 crates/sqlbuild-core/src/screen_text/main/render_tree_group.rs create mode 100644 crates/sqlbuild-core/src/screen_text/mod.rs create mode 100644 crates/sqlbuild-core/src/screen_text/models.rs create mode 100644 crates/sqlbuild-core/src/screen_text/tests.rs create mode 100644 crates/sqlbuild-core/src/screen_text/tests/helpers.rs create mode 100644 crates/sqlbuild-core/src/screen_text/tests/test_screen_text.rs create mode 100644 crates/sqlbuild-core/src/screen_text/tests/test_types.rs diff --git a/crates/sqlbuild-core/src/cli_text/constants.rs b/crates/sqlbuild-core/src/cli_text/constants.rs index 483b68b65d..554d2fe9a0 100644 --- a/crates/sqlbuild-core/src/cli_text/constants.rs +++ b/crates/sqlbuild-core/src/cli_text/constants.rs @@ -6,6 +6,7 @@ pub(crate) const RED: &str = "\x1b[38;5;167m"; pub(crate) const GREEN: &str = "\x1b[32m"; pub(crate) const YELLOW: &str = "\x1b[33m"; pub(crate) const BLUE: &str = "\x1b[34m"; +pub(crate) const CYAN: &str = "\x1b[36m"; pub(crate) const ORANGE: &str = "\x1b[38;5;208m"; pub(crate) const RESET: &str = "\x1b[0m"; pub(crate) const SUCCESS_STATUS_LABELS: [&str; 3] = ["OK", "PASS", "SUCCESS"]; diff --git a/crates/sqlbuild-core/src/cli_text/models.rs b/crates/sqlbuild-core/src/cli_text/models.rs index 572efa79f1..2dbb54cc38 100644 --- a/crates/sqlbuild-core/src/cli_text/models.rs +++ b/crates/sqlbuild-core/src/cli_text/models.rs @@ -1,7 +1,7 @@ //! Plain data of the human compile report, and the semantic styling it is rendered with. use crate::cli_text::constants::{ - BLUE, BOLD, DIM, ERROR_STATUS_LABELS, GREEN, ORANGE, RED, RESET, SKIPPED_STATUS_LABELS, + BLUE, BOLD, CYAN, DIM, ERROR_STATUS_LABELS, GREEN, ORANGE, RED, RESET, SKIPPED_STATUS_LABELS, SUCCESS_STATUS_LABELS, WARNING_STATUS_LABELS, YELLOW, }; @@ -50,6 +50,12 @@ impl CliStyle { self.apply(BLUE, text) } + /// Cyan: URLs and started runs on the live screens. + #[must_use] + pub fn link(self, text: &str) -> String { + self.apply(CYAN, text) + } + #[must_use] pub fn accent(self, text: &str) -> String { self.apply(BLUE, text) diff --git a/crates/sqlbuild-core/src/lib.rs b/crates/sqlbuild-core/src/lib.rs index 0b6f781eea..318a55720a 100644 --- a/crates/sqlbuild-core/src/lib.rs +++ b/crates/sqlbuild-core/src/lib.rs @@ -52,6 +52,7 @@ pub mod progress; pub mod query_command; pub mod redaction; pub mod scenario_command; +pub mod screen_text; pub mod seed_command; pub mod shell_text; pub mod terminal_events; diff --git a/crates/sqlbuild-core/src/screen_text/_helpers/mod.rs b/crates/sqlbuild-core/src/screen_text/_helpers/mod.rs new file mode 100644 index 0000000000..0e38b6c271 --- /dev/null +++ b/crates/sqlbuild-core/src/screen_text/_helpers/mod.rs @@ -0,0 +1,2 @@ +pub(crate) mod phase_tones; +pub(crate) mod rows; diff --git a/crates/sqlbuild-core/src/screen_text/_helpers/phase_tones.rs b/crates/sqlbuild-core/src/screen_text/_helpers/phase_tones.rs new file mode 100644 index 0000000000..710a9db56c --- /dev/null +++ b/crates/sqlbuild-core/src/screen_text/_helpers/phase_tones.rs @@ -0,0 +1,47 @@ +//! The glyph and colours of each phase state. + +use crate::screen_text::constants::{ + FAIL_GLYPH, OK_GLYPH, PENDING_GLYPH, SPINNER_FRAMES, WARN_GLYPH, +}; +use crate::screen_text::models::{PhaseState, Tone}; + +/// How one phase line paints its glyph, label, detail and time. +pub(crate) struct PhaseTones { + pub(crate) glyph: &'static str, + pub(crate) glyph_tone: Tone, + pub(crate) label: Tone, + pub(crate) detail: Tone, + pub(crate) time: Tone, +} + +/// Dim while pending, a yellow spinner and timer while running, then green, yellow or red. +pub(crate) fn phase_tones(state: PhaseState) -> PhaseTones { + let (glyph, glyph_tone): (&'static str, Tone) = match state { + PhaseState::Pending => (PENDING_GLYPH, Tone::Muted), + PhaseState::Running { frame } => { + (SPINNER_FRAMES[frame % SPINNER_FRAMES.len()], Tone::Warning) + } + PhaseState::Ok => (OK_GLYPH, Tone::Success), + PhaseState::Warn => (WARN_GLYPH, Tone::Warning), + PhaseState::Fail => (FAIL_GLYPH, Tone::Error), + }; + PhaseTones { + glyph, + glyph_tone, + label: if state == PhaseState::Pending { + Tone::Muted + } else { + Tone::Plain + }, + detail: match state { + PhaseState::Warn => Tone::Warning, + PhaseState::Fail => Tone::Error, + _ => Tone::Muted, + }, + time: if matches!(state, PhaseState::Running { .. }) { + Tone::Warning + } else { + Tone::Muted + }, + } +} diff --git a/crates/sqlbuild-core/src/screen_text/_helpers/rows.rs b/crates/sqlbuild-core/src/screen_text/_helpers/rows.rs new file mode 100644 index 0000000000..640a310506 --- /dev/null +++ b/crates/sqlbuild-core/src/screen_text/_helpers/rows.rs @@ -0,0 +1,148 @@ +//! Cut, pad and style the spans of one screen row so it never wraps. + +use std::time::Duration; + +use crate::screen_text::constants::{ + CUT_MARK, OSC8_END, OSC8_START, SECONDS_PER_HOUR, SECONDS_PER_MINUTE, TENTHS_PER_MINUTE, +}; +use crate::screen_text::models::{ScreenFacts, Segment, Tone}; +use crate::text::main::cell_len::cell_len; +use crate::text::main::char_cells::char_cells; + +/// A span of `text` in `tone`. +pub(crate) fn span(text: impl Into, tone: Tone) -> Segment { + Segment { + text: text.into(), + tone, + link: None, + } +} + +/// A span of `text` in `tone` that links to `link`. +pub(crate) fn linked(text: impl Into, tone: Tone, link: Option) -> Segment { + Segment { + text: text.into(), + tone, + link, + } +} + +/// The leading characters of `text` that fit in `cells`. +pub(crate) fn take_cells(text: &str, cells: usize) -> String { + let mut used: usize = 0; + let mut kept: String = String::new(); + for character in text.chars() { + let width: usize = char_cells(character); + if used + width > cells { + break; + } + used += width; + kept.push(character); + } + kept +} + +/// `text` cut to `cells` with a trailing `…` when it is wider. +pub(crate) fn cut(text: &str, cells: usize) -> String { + if cell_len(text) <= cells { + return text.to_owned(); + } + if cells == 0 { + return String::new(); + } + format!("{}{CUT_MARK}", take_cells(text, cells - 1)) +} + +/// `text` cut to `cells`, then padded with spaces to exactly `cells`. +pub(crate) fn column(text: &str, cells: usize) -> String { + let kept: String = cut(text, cells); + let padding: usize = cells.saturating_sub(cell_len(&kept)); + format!("{kept}{}", " ".repeat(padding)) +} + +/// `text` right-aligned in `cells`. +pub(crate) fn right(text: &str, cells: usize) -> String { + format!("{}{text}", " ".repeat(cells.saturating_sub(cell_len(text)))) +} + +/// An elapsed time as `0.1s`, `16m 43s` or `2h 5m`, truncated rather than rounded. +pub(crate) fn elapsed_text(elapsed: Duration) -> String { + let tenths: u128 = elapsed.as_millis() / 100; + if tenths < TENTHS_PER_MINUTE { + return format!("{}.{}s", tenths / 10, tenths % 10); + } + let seconds: u64 = elapsed.as_secs(); + if seconds < SECONDS_PER_HOUR { + return format!( + "{}m {}s", + seconds / SECONDS_PER_MINUTE, + seconds % SECONDS_PER_MINUTE + ); + } + format!( + "{}h {}m", + seconds / SECONDS_PER_HOUR, + (seconds % SECONDS_PER_HOUR) / SECONDS_PER_MINUTE + ) +} + +/// The indented row of `segments`, without trailing spaces, cut with `…` to the screen width. +pub(crate) fn render_row(segments: Vec, facts: &ScreenFacts) -> String { + let segments: Vec = without_trailing_space(segments); + let budget: usize = facts.columns.saturating_sub(facts.indent); + let total: usize = segments.iter().map(|segment| cell_len(&segment.text)).sum(); + let mut row: String = " ".repeat(facts.indent); + if total <= budget { + for segment in &segments { + row.push_str(&styled(&segment.text, segment, facts)); + } + return row; + } + let keep: usize = budget.saturating_sub(1); + let mut used: usize = 0; + for segment in &segments { + if used >= keep { + break; + } + let text: String = take_cells(&segment.text, keep - used); + used += cell_len(&text); + row.push_str(&styled(&text, segment, facts)); + } + if budget > 0 { + row.push_str(&facts.style.muted(CUT_MARK)); + } + row +} + +fn without_trailing_space(mut segments: Vec) -> Vec { + while segments + .last() + .is_some_and(|segment| segment.text.trim_end().is_empty()) + { + segments.pop(); + } + if let Some(last) = segments.last_mut() { + last.text.truncate(last.text.trim_end().len()); + } + segments +} + +fn styled(text: &str, segment: &Segment, facts: &ScreenFacts) -> String { + let style = facts.style; + let painted: String = match segment.tone { + Tone::Plain => text.to_owned(), + Tone::Muted => style.muted(text), + Tone::Strong => style.section(text), + Tone::Success => style.success(text), + Tone::Warning => style.warning(text), + Tone::Error => style.error(text), + Tone::Change => style.value(text), + Tone::Link => style.link(text), + }; + match &segment.link { + Some(target) if facts.links && !text.is_empty() => { + format!("{OSC8_START}{target}{OSC8_END}{painted}{OSC8_START}{OSC8_END}") + } + _ => painted, + } +} diff --git a/crates/sqlbuild-core/src/screen_text/constants.rs b/crates/sqlbuild-core/src/screen_text/constants.rs new file mode 100644 index 0000000000..5fedecfaa5 --- /dev/null +++ b/crates/sqlbuild-core/src/screen_text/constants.rs @@ -0,0 +1,44 @@ +//! The glyphs, widths and escapes of live terminal screens. + +pub(crate) const OK_GLYPH: &str = "\u{2713}"; +pub(crate) const WARN_GLYPH: &str = "\u{26a0}"; +pub(crate) const FAIL_GLYPH: &str = "\u{2717}"; +pub(crate) const PENDING_GLYPH: &str = "\u{b7}"; +pub(crate) const CHANGED_GLYPH: &str = "~"; +pub(crate) const RESTARTED_GLYPH: &str = "\u{21bb}"; +pub(crate) const STARTED_GLYPH: &str = "\u{25b6}"; +pub(crate) const CARD_GLYPH: &str = "\u{279c}"; +pub(crate) const CONNECTED_GLYPH: &str = "\u{25cf}"; +pub(crate) const DISCONNECTED_GLYPH: &str = "\u{25cb}"; +pub(crate) const SPINNER_FRAMES: [&str; 10] = [ + "\u{280b}", "\u{2819}", "\u{2839}", "\u{2838}", "\u{283c}", "\u{2834}", "\u{2826}", "\u{2827}", + "\u{2807}", "\u{280f}", +]; +/// What replaces the cut tail of a row. +pub(crate) const CUT_MARK: &str = "\u{2026}"; +pub(crate) const SEPARATOR: &str = " \u{b7} "; +pub(crate) const RULE_CHAR: char = '\u{2500}'; +pub(crate) const TREE_BRANCH: &str = "\u{251c}\u{2500}\u{2500} "; +pub(crate) const TREE_LAST: &str = "\u{2514}\u{2500}\u{2500} "; +pub(crate) const TREE_BAR: &str = "\u{2502} "; +pub(crate) const TREE_SPACE: &str = " "; +pub(crate) const PRODUCT: &str = "sqlbuild dev"; +pub(crate) const PLAIN_PREFIX: &str = "sqlbuild dev: "; +/// The label column of a phase line. +pub(crate) const PHASE_LABEL_WIDTH: usize = 20; +/// The right-aligned time column of phase and event lines. +pub(crate) const TIME_WIDTH: usize = 8; +pub(crate) const EVENT_CLOCK_WIDTH: usize = 8; +pub(crate) const EVENT_TITLE_WIDTH: usize = 32; +pub(crate) const EVENT_DETAIL_WIDTH: usize = 18; +pub(crate) const CARD_LABEL_WIDTH: usize = 12; +/// Times under a minute show tenths of a second. +pub(crate) const TENTHS_PER_MINUTE: u128 = 600; +pub(crate) const SECONDS_PER_MINUTE: u64 = 60; +pub(crate) const SECONDS_PER_HOUR: u64 = 3600; +pub(crate) const OSC8_START: &str = "\u{1b}]8;;"; +pub(crate) const OSC8_END: &str = "\u{1b}\\"; +/// Moves the cursor up `n` rows to column one, then clears to the end of the screen. +pub(crate) const CURSOR_UP: &str = "\u{1b}["; +pub(crate) const CURSOR_UP_END: &str = "F"; +pub(crate) const CLEAR_BELOW: &str = "\u{1b}[J"; diff --git a/crates/sqlbuild-core/src/screen_text/main/format_elapsed.rs b/crates/sqlbuild-core/src/screen_text/main/format_elapsed.rs new file mode 100644 index 0000000000..2d1901fd99 --- /dev/null +++ b/crates/sqlbuild-core/src/screen_text/main/format_elapsed.rs @@ -0,0 +1,11 @@ +//! The elapsed time every screen shows. + +use std::time::Duration; + +use crate::screen_text::_helpers::rows::elapsed_text; + +/// `0.1s` under a minute, `16m 43s` under an hour, else `2h 5m`. +#[must_use] +pub fn format_elapsed(elapsed: Duration) -> String { + elapsed_text(elapsed) +} diff --git a/crates/sqlbuild-core/src/screen_text/main/format_plain_line.rs b/crates/sqlbuild-core/src/screen_text/main/format_plain_line.rs new file mode 100644 index 0000000000..4e8ea54dee --- /dev/null +++ b/crates/sqlbuild-core/src/screen_text/main/format_plain_line.rs @@ -0,0 +1,15 @@ +//! One stable line of the plain `sqb dev` output. + +use std::time::Duration; + +use crate::screen_text::_helpers::rows::elapsed_text; +use crate::screen_text::constants::PLAIN_PREFIX; + +/// `sqlbuild dev: `, followed by ` ()` when timed. +#[must_use] +pub fn format_plain_line(message: &str, elapsed: Option) -> String { + match elapsed { + Some(elapsed) => format!("{PLAIN_PREFIX}{message} ({})", elapsed_text(elapsed)), + None => format!("{PLAIN_PREFIX}{message}"), + } +} diff --git a/crates/sqlbuild-core/src/screen_text/main/mod.rs b/crates/sqlbuild-core/src/screen_text/main/mod.rs new file mode 100644 index 0000000000..9bd1d6dfe5 --- /dev/null +++ b/crates/sqlbuild-core/src/screen_text/main/mod.rs @@ -0,0 +1,10 @@ +pub mod format_elapsed; +pub mod format_plain_line; +pub mod redraw_rows; +pub mod render_dev_header; +pub mod render_event_line; +pub mod render_frame_rule; +pub mod render_hotkey_bar; +pub mod render_phase_lines; +pub mod render_ready_card; +pub mod render_tree_group; diff --git a/crates/sqlbuild-core/src/screen_text/main/redraw_rows.rs b/crates/sqlbuild-core/src/screen_text/main/redraw_rows.rs new file mode 100644 index 0000000000..76fd5632b6 --- /dev/null +++ b/crates/sqlbuild-core/src/screen_text/main/redraw_rows.rs @@ -0,0 +1,20 @@ +//! Redraw a block of rows in place. + +use std::fmt::Write; + +use crate::screen_text::constants::{CLEAR_BELOW, CURSOR_UP, CURSOR_UP_END}; + +/// Move up over the `previous` rows, clear them, and draw `rows`, each already fitting one line. +#[must_use] +pub fn redraw_rows(previous: usize, rows: &[String]) -> String { + let mut text: String = String::new(); + if previous > 0 { + let _ = write!(text, "{CURSOR_UP}{previous}{CURSOR_UP_END}"); + } + text.push_str(CLEAR_BELOW); + for row in rows { + text.push_str(row); + text.push('\n'); + } + text +} diff --git a/crates/sqlbuild-core/src/screen_text/main/render_dev_header.rs b/crates/sqlbuild-core/src/screen_text/main/render_dev_header.rs new file mode 100644 index 0000000000..cd6f86734c --- /dev/null +++ b/crates/sqlbuild-core/src/screen_text/main/render_dev_header.rs @@ -0,0 +1,23 @@ +//! The first line of the `sqb dev` screen. + +use crate::screen_text::_helpers::rows::{render_row, span}; +use crate::screen_text::constants::{PRODUCT, SEPARATOR}; +use crate::screen_text::models::{DevHeader, ScreenFacts, Tone}; + +/// `sqlbuild dev v0.1.0 · shop · target dev`. +#[must_use] +pub fn render_dev_header(header: &DevHeader, facts: &ScreenFacts) -> String { + render_row( + vec![ + span(PRODUCT, Tone::Strong), + span( + format!( + " v{}{SEPARATOR}{}{SEPARATOR}target {}", + header.version, header.project, header.target + ), + Tone::Muted, + ), + ], + facts, + ) +} diff --git a/crates/sqlbuild-core/src/screen_text/main/render_event_line.rs b/crates/sqlbuild-core/src/screen_text/main/render_event_line.rs new file mode 100644 index 0000000000..49258921a1 --- /dev/null +++ b/crates/sqlbuild-core/src/screen_text/main/render_event_line.rs @@ -0,0 +1,54 @@ +//! One timestamped event line of the `sqb dev` screen. + +use crate::screen_text::_helpers::rows::{column, elapsed_text, render_row, right, span}; +use crate::screen_text::constants::{ + CHANGED_GLYPH, EVENT_CLOCK_WIDTH, EVENT_DETAIL_WIDTH, EVENT_TITLE_WIDTH, FAIL_GLYPH, OK_GLYPH, + RESTARTED_GLYPH, STARTED_GLYPH, TIME_WIDTH, +}; +use crate::screen_text::models::{EventLine, EventMark, ScreenFacts, Segment, Tone}; + +/// `09:41:03 ✓ title detail 1.4s`, then each note indented under the title. +#[must_use] +pub fn render_event_line(event: &EventLine, facts: &ScreenFacts) -> Vec { + let (glyph, tone): (&str, Tone) = match event.mark { + EventMark::Changed => (CHANGED_GLYPH, Tone::Change), + EventMark::Succeeded => (OK_GLYPH, Tone::Success), + EventMark::Failed => (FAIL_GLYPH, Tone::Error), + EventMark::Restarted => (RESTARTED_GLYPH, Tone::Warning), + EventMark::Started => (STARTED_GLYPH, Tone::Link), + }; + let title_tone: Tone = if event.mark == EventMark::Failed { + Tone::Error + } else { + Tone::Plain + }; + let mut segments: Vec = vec![ + span(format!("{} ", event.clock), Tone::Muted), + span(format!("{glyph} "), tone), + ]; + if event.detail.is_empty() && event.elapsed.is_none() { + segments.push(span(event.title.as_str(), title_tone)); + } else { + segments.push(span( + column(&event.title, EVENT_TITLE_WIDTH - 1), + title_tone, + )); + segments.push(span( + format!(" {}", column(&event.detail, EVENT_DETAIL_WIDTH - 1)), + Tone::Muted, + )); + let time: String = event.elapsed.map(elapsed_text).unwrap_or_default(); + segments.push(span( + format!(" {}", right(&time, TIME_WIDTH - 1)), + Tone::Muted, + )); + } + let mut rows: Vec = vec![render_row(segments, facts)]; + for note in &event.notes { + let mut note_segments: Vec = + vec![span(" ".repeat(EVENT_CLOCK_WIDTH + 2), Tone::Plain)]; + note_segments.extend(note.iter().cloned()); + rows.push(render_row(note_segments, facts)); + } + rows +} diff --git a/crates/sqlbuild-core/src/screen_text/main/render_frame_rule.rs b/crates/sqlbuild-core/src/screen_text/main/render_frame_rule.rs new file mode 100644 index 0000000000..aad507a9d7 --- /dev/null +++ b/crates/sqlbuild-core/src/screen_text/main/render_frame_rule.rs @@ -0,0 +1,20 @@ +//! The dim rule that frames a client's own terminal output. + +use crate::screen_text::_helpers::rows::{render_row, span}; +use crate::screen_text::constants::RULE_CHAR; +use crate::screen_text::models::{ScreenFacts, Tone}; +use crate::text::main::cell_len::cell_len; + +/// `──