Files
craft-libs/crates/theme/src/dump.rs
T
aiongg e89d434cc1 framework-01-w2: net change of 7 commits
- framework-01-w2: repair 1
- framework-01-w2: RowStyle and ShapeTokens::rows go (size.rs, lib.rs rows of the sheet)
- framework-01-w2: list rows: option rows rounded, others square; layer rules in every theme (show.rs row of the sheet)
- framework-01-w2: review fixes (review-1)
- framework-01-w2: review fixes (review-1, files the rulings name)
- framework-01-w2: the escaped-sweep trial follows the sweep rule: only the eyes it switched are restored (fw01 round 2)
- framework-01-w2: a drop past the last item in reading order lands at the end, in every layout (fwcw round 3)
2026-11-15 04:46:05 +00:00

276 lines
10 KiB
Rust

//! Token text dump: every token of a resolved [`Tokens`] as ordered `key = value` lines.
//!
//! The struct destructuring is exhaustive on purpose: a new token doesn't compile until it is
//! dumped.
use std::fmt::Write as _;
use crate::{
BarSizes, ColorToken, ControlSizes, DialogSizes, DockColumnSizes, Easing, Edge, Elevation, ElevationTokens, FloatSizes, FontSlot, Gaps,
HandleSizes, HitSizes, IconSizes, Insets, KnobShape, LengthSizes, Motion, MotionTokens, NoticeSizes, Pads, PaneSizes, PlotSizes, RadiusSet,
RailSizes, RampSizes, Rgba, RowSizes, RulerSizes, RulerTickSizes, ShapeTokens, SizeTokens, SpaceTokens, StorySizes, StrokeTokens, ThumbSamples,
ThumbSizes, Tokens, TypeStyle, TypeTokens, WellShape, WindowSizes,
};
/// The text of every token, one `key = value` line each, in a fixed order.
pub fn tokens_text(tokens: &Tokens) -> String {
let mut out = Lines::default();
let Tokens { color, shape, space, size, stroke, typography, elevation, motion } = tokens;
for &token in ColorToken::ALL {
out.line(token.path(), hex(color.get(token)));
}
shape_lines(&mut out, shape);
space_lines(&mut out, space);
size_lines(&mut out, size);
stroke_lines(&mut out, stroke);
type_lines(&mut out, typography);
elevation_lines(&mut out, elevation);
motion_lines(&mut out, motion);
out.0
}
/// Ordered `key = value` lines.
#[derive(Default)]
struct Lines(String);
impl Lines {
fn line(&mut self, key: &str, value: impl std::fmt::Display) {
let _ = writeln!(self.0, "{key} = {value}");
}
}
/// `#rrggbbaa`, alpha always written.
fn hex(c: Rgba) -> String {
let [r, g, b, a] = c.0;
format!("#{r:02x}{g:02x}{b:02x}{a:02x}")
}
/// A length with up to two decimals.
fn len(v: f32) -> String {
decimals(v, 2)
}
/// `v` with up to `places` decimals, trailing zeros dropped.
fn decimals(v: f32, places: usize) -> String {
let s = format!("{v:.places$}");
let s = if s.contains('.') { s.trim_end_matches('0').trim_end_matches('.') } else { &s };
if s == "-0" { "0".to_owned() } else { s.to_owned() }
}
fn edge(e: Edge) -> String {
match e {
Edge::Flat => "flat".to_owned(),
Edge::Bevel { light, dark, width } => format!("bevel {} {} {}", hex(light), hex(dark), len(width)),
}
}
fn shape_lines(out: &mut Lines, shape: &ShapeTokens) {
let ShapeTokens { radius, edge: e, knob, wells } = shape;
let RadiusSet { sm, control, surface, window, panel, button, pill } = radius;
for (k, v) in [("sm", sm), ("control", control), ("surface", surface), ("window", window), ("panel", panel), ("button", button), ("pill", pill)] {
out.line(&format!("shape.radius.{k}"), len(*v));
}
out.line("shape.edge", edge(*e));
out.line("shape.knob", if *knob == KnobShape::Round { "round" } else { "tab" });
out.line("shape.wells", if *wells == WellShape::Square { "square" } else { "round" });
}
fn stroke_lines(out: &mut Lines, stroke: &StrokeTokens) {
let StrokeTokens { thin, medium, thick, heavy, dash, dash_gap, icon } = stroke;
for (k, v) in [("thin", thin), ("medium", medium), ("thick", thick), ("heavy", heavy), ("dash", dash), ("dash_gap", dash_gap)] {
out.line(&format!("stroke.{k}"), len(*v));
}
out.line("stroke.icon", decimals(*icon, 4));
}
fn space_lines(out: &mut Lines, space: &SpaceTokens) {
let SpaceTokens { gap, pad, inset } = space;
let Gaps { tight, inline, row, stack, item, section, card_column, card_row } = gap;
for (k, v) in [
("tight", tight),
("inline", inline),
("row", row),
("stack", stack),
("item", item),
("section", section),
("card_column", card_column),
("card_row", card_row),
] {
out.line(&format!("space.gap.{k}"), len(*v));
}
let Pads { control, regular, roomy, chip, segment } = pad;
for (k, v) in [("control", control), ("regular", regular), ("roomy", roomy), ("chip", chip), ("segment", segment)] {
out.line(&format!("space.pad.{k}"), len(*v));
}
let Insets { screen } = inset;
out.line("space.inset.screen", len(*screen));
}
fn size_lines(out: &mut Lines, size: &SizeTokens) {
let SizeTokens {
control,
icon,
rail,
bar,
panel_header,
popup_min,
scroll_fade,
thumb: thumbs,
handle,
hit,
checker,
plot,
length,
row,
groove,
ramp,
pointer_tip,
float,
window,
pane,
ruler,
dock,
notice,
dialog,
story,
} = size;
let ControlSizes { sm, md } = control;
out.line("size.control.sm", len(*sm));
out.line("size.control.md", len(*md));
let IconSizes { sm, md, lg, glyph_sm, glyph_md } = icon;
out.line("size.icon.sm", len(*sm));
out.line("size.icon.md", len(*md));
out.line("size.icon.lg", len(*lg));
out.line("size.icon.glyph_sm", len(*glyph_sm));
out.line("size.icon.glyph_md", len(*glyph_md));
let RailSizes { width, button } = rail;
out.line("size.rail.width", len(*width));
out.line("size.rail.button", len(*button));
let BarSizes { title, tab, status, options, options_narrow } = bar;
for (k, v) in [("title", title), ("tab", tab), ("status", status), ("options", options), ("options_narrow", options_narrow)] {
out.line(&format!("size.bar.{k}"), len(*v));
}
out.line("size.panel_header", len(*panel_header));
out.line("size.popup_min", len(*popup_min));
out.line("size.scroll_fade", len(*scroll_fade));
let ThumbSizes { sm, md, lg, card, sample } = thumbs;
out.line("size.thumb.sm", len(*sm));
out.line("size.thumb.md", len(*md));
out.line("size.thumb.lg", len(*lg));
out.line("size.thumb.card", len(*card));
let ThumbSamples { sm, md, lg } = sample;
out.line("size.thumb.sample.sm", len(*sm));
out.line("size.thumb.sample.md", len(*md));
out.line("size.thumb.sample.lg", len(*lg));
let HandleSizes { sm, md, ring } = handle;
out.line("size.handle.sm", len(*sm));
out.line("size.handle.md", len(*md));
out.line("size.handle.ring", len(*ring));
let HitSizes { slop, target, edge } = hit;
out.line("size.hit.slop", len(*slop));
out.line("size.hit.target", len(*target));
out.line("size.hit.edge", len(*edge));
out.line("size.checker", len(*checker));
let PlotSizes { width, height } = plot;
out.line("size.plot.width", len(*width));
out.line("size.plot.height", len(*height));
let LengthSizes { field, track, short, number } = length;
out.line("size.length.field.sm", len(field.sm));
out.line("size.length.field.md", len(field.md));
out.line("size.length.track", len(*track));
out.line("size.length.short", len(*short));
out.line("size.length.number.sm", len(number.sm));
out.line("size.length.number.md", len(number.md));
let RowSizes { text } = row;
out.line("size.row.text", len(*text));
out.line("size.groove", len(*groove));
let RampSizes { bar, groove: ramp_groove } = ramp;
out.line("size.ramp.bar", len(*bar));
out.line("size.ramp.groove", len(*ramp_groove));
out.line("size.pointer_tip.x", len(pointer_tip.x));
out.line("size.pointer_tip.y", len(pointer_tip.y));
let FloatSizes { width, height } = float;
out.line("size.float.width", len(*width));
out.line("size.float.height", len(*height));
let WindowSizes { cascade } = window;
out.line("size.window.cascade", len(*cascade));
let PaneSizes { least } = pane;
out.line("size.pane.least", len(*least));
let RulerSizes { tick } = ruler;
let RulerTickSizes { mid } = tick;
out.line("size.ruler.tick.mid", len(*mid));
let DockColumnSizes { column } = dock;
out.line("size.dock.column", len(*column));
let NoticeSizes { width } = notice;
out.line("size.notice.width", len(*width));
let DialogSizes { least, wrap, button, side_button } = dialog;
out.line("size.dialog.least", len(*least));
out.line("size.dialog.wrap", len(*wrap));
out.line("size.dialog.button", len(*button));
out.line("size.dialog.side_button", len(*side_button));
let StorySizes { height, width_min, width_max } = story;
out.line("size.story.height", len(*height));
out.line("size.story.width_min", len(*width_min));
out.line("size.story.width_max", len(*width_max));
}
fn slot(s: FontSlot) -> &'static str {
match s {
FontSlot::Ui => "ui",
FontSlot::UiSemibold => "ui_semibold",
FontSlot::Mono => "mono",
}
}
fn type_lines(out: &mut Lines, t: &TypeTokens) {
let TypeTokens { caption, label, body, body_strong, title, heading, body_large, mono, display } = t;
let roles = [
("caption", caption),
("label", label),
("body", body),
("body_strong", body_strong),
("title", title),
("heading", heading),
("body_large", body_large),
("mono", mono),
("display", display),
];
for (k, style) in roles {
let TypeStyle { size, line_height, font } = style;
out.line(&format!("typography.{k}.size"), len(*size));
out.line(&format!("typography.{k}.line_height"), len(*line_height));
out.line(&format!("typography.{k}.font"), slot(*font));
}
}
fn elevation_lines(out: &mut Lines, e: &ElevationTokens) {
let ElevationTokens { popup, floating, knob } = e;
for (k, level) in [("popup", popup), ("floating", floating), ("knob", knob)] {
let Elevation { offset: [x, y], blur, spread, alpha } = level;
out.line(&format!("elevation.{k}.offset"), format!("{} {}", len(*x), len(*y)));
out.line(&format!("elevation.{k}.blur"), len(*blur));
out.line(&format!("elevation.{k}.spread"), len(*spread));
out.line(&format!("elevation.{k}.alpha"), decimals(*alpha, 3));
}
}
fn easing(e: Easing) -> &'static str {
match e {
Easing::Standard => "standard",
Easing::Enter => "enter",
Easing::Exit => "exit",
}
}
fn motion_lines(out: &mut Lines, m: &MotionTokens) {
let MotionTokens { hover, open, r#move, caret, outline, reduced } = m;
for (k, motion) in [("hover", hover), ("open", open), ("move", r#move), ("caret", caret), ("outline", outline)] {
let Motion { millis, easing: e } = motion;
out.line(&format!("motion.{k}.millis"), millis);
out.line(&format!("motion.{k}.easing"), easing(*e));
}
out.line("motion.reduced", reduced);
}