typst-cli 0.15.0

The command line interface for Typst.
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
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

use std::any::Any;
use std::fmt::{self, Display, Formatter};
use std::path::Path;

use typst::text::{
    AxisValue, FontAxis, FontInfo, FontStretch, FontVariant, FontWeight, StandardAxes,
};
use typst_kit::fonts::{self, FontPath, FontStore};

use crate::args::{FontArgs, FontsCommand};

/// Execute a font listing command.
pub fn fonts(command: &FontsCommand) {
    let fonts = discover_fonts(&command.font);

    for (family, indices) in fonts.book().families() {
        println!("{family}");
        if command.variants {
            let mut indices = indices.peekable();
            while let Some(index) = indices.next() {
                let info = fonts.book().info(index).unwrap();
                let path = fonts
                    .source(index)
                    .and_then(|source| (source as &dyn Any).downcast_ref::<FontPath>())
                    .map(|font| font.path.as_path());
                let last = indices.peek().is_none();
                let variant =
                    typst_utils::display(|f| write_variant(f, info, path, last));
                print!("{variant}");
            }
            println!();
        }
    }
}

/// Discovers the fonts as specified by the CLI flags.
#[typst_macros::time(name = "discover fonts")]
pub fn discover_fonts(args: &FontArgs) -> FontStore {
    let mut fonts = FontStore::new();

    if !args.ignore_system_fonts {
        fonts.extend(fonts::system());
    }

    #[cfg(feature = "embedded-fonts")]
    if !args.ignore_embedded_fonts {
        fonts.extend(fonts::embedded());
    }

    for path in &args.font_paths {
        fonts.extend(fonts::scan(path));
    }

    fonts
}

/// Displays information for one font file / variant.
fn write_variant(
    f: &mut Formatter,
    info: &FontInfo,
    path: Option<&Path>,
    last: bool,
) -> fmt::Result {
    let path = typst_utils::display(|f| match path {
        Some(path) => path.display().fmt(f),
        None => f.pad("(Embedded)"),
    });

    let FontVariant { style, weight, stretch } = info.variant;
    let marker = if last { '└' } else { '├' };
    let pad = if last { "     " } else { "  │  " };

    let mut axes = info.axes.to_vec();
    axes.sort_by_key(|axis| StandardAxes::order(axis.tag));

    if axes.is_empty() {
        writeln!(f, "  {marker} {path}")?;
        writeln!(f, "{pad} Style: {style:?}, Weight: {weight}, Stretch: {stretch}")?;
    } else {
        writeln!(f, "  {marker} {path} (Variable)")?;
        let standard = StandardAxes::parse(&axes);
        if standard.ital.is_none() && standard.slnt.is_none() {
            writeln!(f, "{pad} Style: {style:?}")?;
        }
        if standard.wght.is_none() {
            writeln!(f, "{pad} Weight: {weight}")?;
        }
        if standard.wdth.is_none() {
            writeln!(f, "{pad} Stretch: {stretch}")?;
        }
        for axis in &axes {
            writeln!(f, "{pad} {}", typst_utils::display(|f| write_axis(f, axis)))?;
        }
    }

    Ok(())
}

/// Formats a variation axis.
fn write_axis(f: &mut Formatter, axis: &FontAxis) -> fmt::Result {
    use std::convert::identity;
    match axis.tag {
        StandardAxes::ITAL => write_axis_with(f, axis, "Italic", identity),
        StandardAxes::SLNT => write_axis_with(f, axis, "Slant", identity),
        StandardAxes::WGHT => write_axis_with(f, axis, "Weight", FontWeight::from_wght),
        StandardAxes::WDTH => write_axis_with(f, axis, "Stretch", FontStretch::from_wdth),
        StandardAxes::OPSZ => write_axis_with(f, axis, "Optical Size", |v| {
            typst_utils::display(move |f| write!(f, "{v}pt"))
        }),
        _ => write_axis_with(f, axis, &axis.tag.to_str_lossy(), identity),
    }
}

/// Formats a variation axis with a specific name and value display function.
fn write_axis_with<T: Display>(
    f: &mut Formatter,
    axis: &FontAxis,
    name: &str,
    show: impl Fn(AxisValue) -> T,
) -> fmt::Result {
    write!(
        f,
        "{name}: {}-{} (Default: {})",
        show(axis.min),
        show(axis.max),
        show(axis.default),
    )
}