aster-ssg 0.3.0

A typst-native static site generator, inspired by Astro.
Documentation
use std::io::Write;
use std::path::PathBuf;

use anyhow::Result;
use comemo::{Track, Tracked};
use termcolor::NoColor;
use typst::diag::{FileError, SourceDiagnostic, SourceResult, Warned};
use typst::ecow::EcoString;
use typst::foundations::Duration;
use typst::foundations::{Bytes, Datetime, Label, Selector, Value};
use typst::introspection::{Introspector, MetadataElem};
use typst::syntax::{FileId, RootedPath, VirtualPath, VirtualRoot};
use typst::text::{Font, FontBook};
use typst::utils::LazyHash;
use typst::{Library, World};
use typst_kit::datetime::Time;
use typst_kit::diagnostics::{self, DiagnosticFormat, DiagnosticWorld};
use typst_kit::fonts::FontStore;

use crate::build::files::ProjectFiles;
use crate::build::{BuildSession, BuildWarning};
use crate::engine::content::CompilationRuntime;
use crate::foundation::ProjectLayout;
use crate::foundation::config::FontConfig;

pub fn configure_fonts(
    session: &mut BuildSession,
    config: &FontConfig,
    layout: &ProjectLayout,
) -> Result<()> {
    let directories = layout
        .font_dirs()
        .map(|path| session.files.directory(path))
        .collect::<Result<Vec<_>, _>>()?;
    let refresh = session.font_config.as_ref() != Some(config) || !config.paths.is_empty();
    if refresh {
        session.fonts = discover_fonts(config, directories.iter().map(PathBuf::as_path));
        session.font_config = Some(config.clone());
    }
    let count = session
        .fonts
        .book()
        .families()
        .map(|(_, variants)| variants.count())
        .sum::<usize>();
    if refresh {
        tracing::debug!(
            fonts = count,
            "discovered {count} font face{}",
            if count == 1 { "" } else { "s" }
        );
    } else {
        tracing::debug!(
            fonts = count,
            "reused {count} font face{}",
            if count == 1 { "" } else { "s" }
        );
    }
    Ok(())
}

pub fn compile_document(
    session: &BuildSession,
    entry: &VirtualPath,
    runtime: &CompilationRuntime<'_>,
    warnings: &mut Vec<BuildWarning>,
) -> Result<typst_html::HtmlDocument> {
    let world = world(session, entry, runtime);
    let warned = compile_html((&world as &dyn World).track());
    let document = warned
        .output
        .map_err(|diagnostics| diagnostic_error(&world, "compilation failed", &diagnostics))?;

    const TYPST_HTML_WARNING: &str = "html export is under active development and incomplete";
    warnings.extend(
        warned
            .warnings
            .iter()
            .filter(|warning| warning.message.as_str() != TYPST_HTML_WARNING)
            .map(|warning| format_warning(&world, warning)),
    );
    Ok(document)
}

pub fn evaluate_generator(
    session: &BuildSession,
    entry: &VirtualPath,
    runtime: &CompilationRuntime<'_>,
    warnings: &mut Vec<BuildWarning>,
) -> Result<Bytes> {
    let document = compile_document(session, entry, runtime, warnings)?;
    let selector = Selector::Label(
        Label::construct("aster-output".into()).expect("generator label is non-empty"),
    );
    let mut declarations = document
        .introspector()
        .query(&selector)
        .into_iter()
        .filter_map(|element| {
            element
                .to_packed::<MetadataElem>()
                .map(|metadata| metadata.value.clone())
        });
    let output = match (declarations.next(), declarations.next()) {
        (_, Some(_)) => {
            anyhow::bail!("generator must contain exactly one <aster-output> declaration")
        }
        (None, None) => anyhow::bail!("generator did not produce <aster-output>"),
        (Some(Value::Str(content)), None) => Bytes::from_string(content),
        (Some(Value::Bytes(content)), None) => content,
        (Some(_), None) => anyhow::bail!("generator output must be a string or bytes"),
    };
    Ok(output)
}

fn world<'a>(
    session: &'a BuildSession,
    entry: &VirtualPath,
    runtime: &'a CompilationRuntime<'a>,
) -> CompileWorld<'a> {
    let main = RootedPath::new(VirtualRoot::Project, entry.clone()).intern();
    CompileWorld {
        runtime,
        fonts: &session.fonts,
        files: &session.files,
        main,
        now: &session.now,
    }
}

fn discover_fonts<'a>(
    config: &FontConfig,
    directories: impl IntoIterator<Item = &'a std::path::Path>,
) -> FontStore {
    let mut fonts = FontStore::new();
    if config.system {
        fonts.extend(typst_kit::fonts::system());
    }
    fonts.extend(typst_kit::fonts::embedded());
    for directory in directories {
        fonts.extend(typst_kit::fonts::scan(directory));
    }
    fonts
}

#[comemo::memoize]
fn compile_html(world: Tracked<dyn World + '_>) -> Warned<SourceResult<typst_html::HtmlDocument>> {
    typst::compile::<typst_html::HtmlDocument>(&*world)
}

fn diagnostic_error(
    world: &CompileWorld<'_>,
    context: &str,
    diagnostics: &[SourceDiagnostic],
) -> anyhow::Error {
    anyhow::anyhow!("{context}\n{}", format_diagnostics(world, diagnostics))
}

fn format_diagnostics(
    world: &impl DiagnosticWorld,
    source_diagnostics: &[SourceDiagnostic],
) -> EcoString {
    format_diagnostics_impl(world, source_diagnostics, "")
}

fn format_diagnostics_impl(
    world: &impl DiagnosticWorld,
    source_diagnostics: &[SourceDiagnostic],
    prefix: &str,
) -> EcoString {
    let mut buffer = Vec::new();
    {
        let mut writer = NoColor::new(&mut buffer);
        if diagnostics::emit(
            &mut writer,
            world,
            source_diagnostics.iter(),
            DiagnosticFormat::Human,
        )
        .is_err()
        {
            for diagnostic in source_diagnostics {
                let _ = writeln!(writer, "error: {diagnostic:?}");
            }
        }
    }
    let output = String::from_utf8_lossy(&buffer);
    let output = output.trim_end();
    output.strip_prefix(prefix).unwrap_or(output).into()
}

fn format_warning(world: &impl DiagnosticWorld, warning: &SourceDiagnostic) -> BuildWarning {
    BuildWarning::new(format_diagnostics_impl(
        world,
        std::slice::from_ref(warning),
        "warning: ",
    ))
}

struct CompileWorld<'a> {
    runtime: &'a CompilationRuntime<'a>,
    fonts: &'a FontStore,
    files: &'a ProjectFiles,
    main: FileId,
    now: &'a Time,
}

impl World for CompileWorld<'_> {
    fn library(&self) -> &LazyHash<Library> {
        self.runtime.library()
    }

    fn book(&self) -> &LazyHash<FontBook> {
        self.fonts.book()
    }

    fn main(&self) -> FileId {
        self.main
    }

    fn source(&self, id: FileId) -> Result<typst::syntax::Source, FileError> {
        if self.runtime.resolve_file(id).is_some() {
            return Err(FileError::NotFound(id.vpath().get_with_slash().into()));
        }
        self.files.source(id)
    }

    fn file(&self, id: FileId) -> Result<Bytes, FileError> {
        if let Some(file) = self.runtime.resolve_file(id) {
            return file;
        }
        self.files.file(id)
    }

    fn font(&self, index: usize) -> Option<Font> {
        self.fonts.font(index)
    }

    fn today(&self, offset: Option<Duration>) -> Option<Datetime> {
        self.now.today(offset)
    }
}

impl DiagnosticWorld for CompileWorld<'_> {
    fn name(&self, id: FileId) -> String {
        match id.root() {
            VirtualRoot::Project => id.vpath().get_without_slash().into(),
            VirtualRoot::Package(package) => {
                format!("{package}{}", id.vpath().get_with_slash())
            }
        }
    }
}

#[cfg(test)]
mod tests {
    use typst::text::FontFlags;

    use super::*;

    #[test]
    fn embedded_math_font_is_always_available() {
        let fonts = discover_fonts(
            &FontConfig {
                system: false,
                ..FontConfig::default()
            },
            std::iter::empty(),
        );
        let book = fonts.book();

        assert!(book.contains_family("new computer modern math"));
        let index = book
            .select_family("new computer modern math")
            .next()
            .unwrap();
        assert!(
            fonts
                .font(index)
                .unwrap()
                .info()
                .flags
                .contains(FontFlags::MATH)
        );
    }
}