uzor-text 1.5.1

Pretext-pattern text layout engine for uzor — greedy word-wrap, rich multi-run spans, InlineBox, and a mixed-run baseline pass over the cosmic-text shaper (Arc 2 Phase 1+2; kinetics/ascii/hyphenation land in later phases).
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

//! Dashboard tiles: label, value, delta, tofu sparkline.

use super::{empty, ink, tofu, Play};
use crate::ascii::{Cell, CellShader, Coord, Cursor, GridContext};

#[derive(Clone, Copy, Debug)]
pub struct KpiTile {
    pub label: &'static str,
    pub value: &'static str,
    pub delta: &'static str,
    pub up: bool,
    pub spark: &'static [f64],
}

pub struct Kpi<'a> {
    pub tiles: &'a [KpiTile],
    pub play: Play,
}

impl CellShader for Kpi<'_> {
    fn main(&self, coord: Coord, ctx: &GridContext, cursor: &Cursor) -> Cell {
        if self.tiles.is_empty() || ctx.cols < 10 || ctx.rows < 5 {
            return empty();
        }
        let n = self.tiles.len();
        let tw = (ctx.cols / n).max(4);
        let i = coord.x / tw;
        if i >= n {
            return empty();
        }
        let tile = self.tiles[i];
        let lx = coord.x - i * tw;
        if lx == 0 || lx + 1 == tw {
            return empty();
        }
        let hover = cursor.inside && (cursor.x as usize) / tw == i;
        let _ = self.play.motion(ctx.time, cursor.intensity);
        if coord.y == 1 {
            return glyph(tile.label, lx.saturating_sub(1), hover, 200.0, 0.45);
        }
        if coord.y == 2 {
            return glyph(tile.value, lx.saturating_sub(1), hover, 160.0, 0.62);
        }
        if coord.y == 3 {
            return glyph(
                tile.delta,
                lx.saturating_sub(1),
                hover,
                if tile.up { 140.0 } else { 8.0 },
                0.5,
            );
        }
        if coord.y + 2 >= ctx.rows || tile.spark.len() < 2 {
            return empty();
        }
        let inner = tw.saturating_sub(2).max(1);
        let col = lx.saturating_sub(1);
        let si = (col * (tile.spark.len() - 1)) / inner;
        let (lo, hi) = min_max(tile.spark);
        let y = tile.spark[si];
        let u = ((y - lo) / (hi - lo).max(1e-6)).clamp(0.0, 1.0);
        let spark_rows = ctx.rows.saturating_sub(5).max(1);
        let row = coord.y.saturating_sub(4);
        if row >= spark_rows {
            return empty();
        }
        let want = ((1.0 - u) * (spark_rows.saturating_sub(1) as f64)).round() as usize;
        if row != want {
            return empty();
        }
        tofu(hover, 175.0, 0.45)
    }
}

fn glyph(s: &str, i: usize, hover: bool, hue: f64, lit: f64) -> Cell {
    match s.chars().nth(i) {
        Some(ch) => ink(ch, hover, hue, lit),
        None => empty(),
    }
}

fn min_max(ys: &[f64]) -> (f64, f64) {
    let mut lo = f64::INFINITY;
    let mut hi = f64::NEG_INFINITY;
    for &y in ys {
        lo = lo.min(y);
        hi = hi.max(y);
    }
    if !lo.is_finite() {
        (0.0, 1.0)
    } else {
        (lo, hi)
    }
}