webfont-generator 0.11.0

Generate webfonts (SVG, TTF, EOT, WOFF, WOFF2) from SVG icons
Documentation 
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

use std::fs;
#[cfg(feature = "fs")]
use std::path::{Path, PathBuf};
#[cfg(feature = "fs")]
use std::time::{SystemTime, UNIX_EPOCH};

use crate::input::{GenerationOptions, LoadedSvgSource, finalize_generate_webfonts_options};
#[cfg(feature = "fs")]
use crate::input::{ResolvedFileGenerationOptions, resolve_generate_webfonts_options};

#[cfg(feature = "fs")]
pub fn resolve_options(options: crate::GenerateWebfontsOptions) -> ResolvedFileGenerationOptions {
    resolve_generate_webfonts_options(options)
        .unwrap_or_else(|error| panic!("native options should resolve: {error}"))
}

#[cfg(feature = "fs")]
pub fn write_temp_template(prefix: &str, contents: &str) -> String {
    let unique = SystemTime::now()
        .duration_since(UNIX_EPOCH)
        .expect("system time should be after unix epoch")
        .as_nanos();
    let path = std::env::temp_dir().join(format!("{prefix}-{}-{unique}.hbs", std::process::id()));
    fs::write(&path, contents).expect("temporary template should be written");
    path.to_string_lossy().into_owned()
}

#[cfg(feature = "fs")]
pub fn fixture_source_files(options: &ResolvedFileGenerationOptions) -> Vec<LoadedSvgSource> {
    vec![LoadedSvgSource {
        contents: fs::read_to_string(&options.files[0])
            .expect("fixture should load")
            .into(),
        glyph_name: Path::new(&options.files[0])
            .file_stem()
            .and_then(|s| s.to_str())
            .unwrap_or("add")
            .to_owned(),
        id: options.files[0].clone(),
    }]
}

pub fn webfont_fixture(name: &str) -> String {
    format!(
        "{}/src/svg/fixtures/unit/{name}",
        env!("CARGO_MANIFEST_DIR")
    )
}

pub fn fixture_font_tables() -> crate::sfnt::SerializedFontTables {
    let mut options = GenerationOptions {
        css: Some(false),
        html: Some(false),
        font_name: Some("iconfont".to_string()),
        ligature: Some(false),
        ..Default::default()
    }
    .resolve(false)
    .expect("fixture options should resolve");
    let source_files = vec![LoadedSvgSource {
        contents: fs::read_to_string(webfont_fixture("add.svg"))
            .expect("fixture should load")
            .into(),
        glyph_name: "add".into(),
        id: webfont_fixture("add.svg"),
    }];
    finalize_generate_webfonts_options(&mut options, &source_files)
        .expect("expected options to finalize");
    let svg_options = crate::svg::svg_options_from_options(&options);
    let prepared = crate::svg::prepare_svg_font(&svg_options, &source_files)
        .expect("expected svg preparation to succeed");
    crate::sfnt::build(
        crate::sfnt::ttf_options_from_options(&options),
        &prepared.processed_glyphs,
        None,
    )
    .expect("expected ttf generation to succeed")
}

#[cfg(feature = "fs")]
pub fn icons_root() -> PathBuf {
    Path::new(env!("CARGO_MANIFEST_DIR"))
        .join("src/svg/fixtures/icons")
        .canonicalize()
        .expect("native icon fixture root should exist")
}

#[cfg(feature = "fs")]
pub fn update_snapshots_enabled() -> bool {
    std::env::var_os("UPDATE_SVG_FIXTURES").is_some_and(|value| value != "0")
}