typst 0.13.3-aarch64-linux

data/ext/typst/src/compiler.rs

@@ -0,0 +1,248 @@
+use chrono::{Datelike, Timelike};
+use codespan_reporting::diagnostic::{Diagnostic, Label};
+use codespan_reporting::term::{self, termcolor};
+use ecow::{eco_format, EcoString};
+use typst::diag::{Severity, SourceDiagnostic, StrResult, Warned};
+use typst::foundations::Datetime;
+use typst::html::HtmlDocument;
+use typst::layout::PagedDocument;
+use typst::syntax::{FileId, Source, Span};
+use typst::{World, WorldExt};
+
+use crate::world::SystemWorld;
+
+type CodespanResult<T> = Result<T, CodespanError>;
+type CodespanError = codespan_reporting::files::Error;
+
+impl SystemWorld {
+    pub fn compile(
+        &mut self,
+        format: Option<&str>,
+        ppi: Option<f32>,
+        pdf_standards: &[typst_pdf::PdfStandard],
+    ) -> StrResult<Vec<Vec<u8>>> {
+        // Reset everything and ensure that the main file is present.
+        self.reset();
+        self.source(self.main()).map_err(|err| err.to_string())?;
+
+        match format.unwrap_or_else(|| "pdf").to_ascii_lowercase().as_str() {
+            "html" => {
+                let Warned { output, warnings } = typst::compile::<HtmlDocument>(self);
+                match output {
+                    Ok(document) => {
+                        Ok(vec![export_html(&document, self)?])
+                    }
+                    Err(errors) => Err(format_diagnostics(self, &errors, &warnings).unwrap().into()),
+                }
+            }
+            _ => {
+                let Warned { output, warnings } = typst::compile::<PagedDocument>(self);
+                match output {
+                    // Export the PDF / PNG.
+                    Ok(document) => {
+                        // Assert format is "pdf" or "png" or "svg"
+                        match format.unwrap_or("pdf").to_ascii_lowercase().as_str() {
+                            "pdf" => Ok(vec![export_pdf(
+                                &document,
+                                self,
+                                typst_pdf::PdfStandards::new(pdf_standards)?,
+                            )?]),
+                            "png" => Ok(export_image(&document, ImageExportFormat::Png, ppi)?),
+                            "svg" => Ok(export_image(&document, ImageExportFormat::Svg, ppi)?),
+                            fmt => Err(eco_format!("unknown format: {fmt}")),
+                        }
+                    }
+                    Err(errors) => Err(format_diagnostics(self, &errors, &warnings).unwrap().into()),
+                }
+            }
+        }
+    }
+}
+
+/// Export to a PDF.
+#[inline]
+fn export_html(
+    document: &HtmlDocument,
+    world: &SystemWorld,
+) -> StrResult<Vec<u8>> {
+    let html = typst_html::html(document)
+    .map_err(|e| match format_diagnostics(world, &e, &[]) {
+        Ok(e) => EcoString::from(e),
+        Err(err) => eco_format!("failed to print diagnostics ({err})"),
+    })?;
+    let buffer = html.as_bytes().to_vec();
+    Ok(buffer)
+}
+
+/// Export to a PDF.
+#[inline]
+fn export_pdf(
+    document: &PagedDocument,
+    world: &SystemWorld,
+    standards: typst_pdf::PdfStandards,
+) -> StrResult<Vec<u8>> {
+    let ident = world.input().to_string_lossy();
+    let buffer = typst_pdf::pdf(
+        document,
+        &typst_pdf::PdfOptions {
+            ident: typst::foundations::Smart::Custom(&ident),
+            timestamp: now().map(typst_pdf::Timestamp::new_utc),
+            standards,
+            ..Default::default()
+        },
+    )
+    .map_err(|e| match format_diagnostics(world, &e, &[]) {
+        Ok(e) => EcoString::from(e),
+        Err(err) => eco_format!("failed to print diagnostics ({err})"),
+    })?;
+    Ok(buffer)
+}
+
+/// Get the current date and time in UTC.
+fn now() -> Option<Datetime> {
+    let now = chrono::Local::now().naive_utc();
+    Datetime::from_ymd_hms(
+        now.year(),
+        now.month().try_into().ok()?,
+        now.day().try_into().ok()?,
+        now.hour().try_into().ok()?,
+        now.minute().try_into().ok()?,
+        now.second().try_into().ok()?,
+    )
+}
+
+/// An image format to export in.
+enum ImageExportFormat {
+    Png,
+    Svg,
+}
+
+/// Export the frames to PNGs or SVGs.
+fn export_image(
+    document: &PagedDocument,
+    fmt: ImageExportFormat,
+    ppi: Option<f32>,
+) -> StrResult<Vec<Vec<u8>>> {
+    let mut buffers = Vec::new();
+    for page in &document.pages {
+        let buffer = match fmt {
+            ImageExportFormat::Png => typst_render::render(page, ppi.unwrap_or(144.0) / 72.0)
+                .encode_png()
+                .map_err(|err| eco_format!("failed to write PNG file ({err})"))?,
+            ImageExportFormat::Svg => {
+                let svg = typst_svg::svg(page);
+                svg.as_bytes().to_vec()
+            }
+        };
+        buffers.push(buffer);
+    }
+    Ok(buffers)
+}
+
+/// Format diagnostic messages.\
+pub fn format_diagnostics(
+    world: &SystemWorld,
+    errors: &[SourceDiagnostic],
+    warnings: &[SourceDiagnostic],
+) -> Result<String, codespan_reporting::files::Error> {
+    let mut w = termcolor::Buffer::no_color();
+
+    let config = term::Config {
+        tab_width: 2,
+        ..Default::default()
+    };
+
+    for diagnostic in warnings.iter().chain(errors.iter()) {
+        let diag = match diagnostic.severity {
+            Severity::Error => Diagnostic::error(),
+            Severity::Warning => Diagnostic::warning(),
+        }
+        .with_message(diagnostic.message.clone())
+        .with_notes(
+            diagnostic
+                .hints
+                .iter()
+                .map(|e| (eco_format!("hint: {e}")).into())
+                .collect(),
+        )
+        .with_labels(label(world, diagnostic.span).into_iter().collect());
+
+        term::emit(&mut w, &config, world, &diag)?;
+
+        // Stacktrace-like helper diagnostics.
+        for point in &diagnostic.trace {
+            let message = point.v.to_string();
+            let help = Diagnostic::help()
+                .with_message(message)
+                .with_labels(label(world, point.span).into_iter().collect());
+
+            term::emit(&mut w, &config, world, &help)?;
+        }
+    }
+
+    let s = String::from_utf8(w.into_inner()).unwrap();
+    Ok(s)
+}
+
+/// Create a label for a span.
+fn label(world: &SystemWorld, span: Span) -> Option<Label<FileId>> {
+    Some(Label::primary(span.id()?, world.range(span)?))
+}
+
+impl<'a> codespan_reporting::files::Files<'a> for SystemWorld {
+    type FileId = FileId;
+    type Name = String;
+    type Source = Source;
+
+    fn name(&'a self, id: FileId) -> CodespanResult<Self::Name> {
+        let vpath = id.vpath();
+        Ok(if let Some(package) = id.package() {
+            format!("{package}{}", vpath.as_rooted_path().display())
+        } else {
+            // Try to express the path relative to the working directory.
+            vpath
+                .resolve(self.root())
+                .and_then(|abs| pathdiff::diff_paths(abs, self.workdir()))
+                .as_deref()
+                .unwrap_or_else(|| vpath.as_rootless_path())
+                .to_string_lossy()
+                .into()
+        })
+    }
+
+    fn source(&'a self, id: FileId) -> CodespanResult<Self::Source> {
+        Ok(self.lookup(id))
+    }
+
+    fn line_index(&'a self, id: FileId, given: usize) -> CodespanResult<usize> {
+        let source = self.lookup(id);
+        source
+            .byte_to_line(given)
+            .ok_or_else(|| CodespanError::IndexTooLarge {
+                given,
+                max: source.len_bytes(),
+            })
+    }
+
+    fn line_range(&'a self, id: FileId, given: usize) -> CodespanResult<std::ops::Range<usize>> {
+        let source = self.lookup(id);
+        source
+            .line_to_range(given)
+            .ok_or_else(|| CodespanError::LineTooLarge {
+                given,
+                max: source.len_lines(),
+            })
+    }
+
+    fn column_number(&'a self, id: FileId, _: usize, given: usize) -> CodespanResult<usize> {
+        let source = self.lookup(id);
+        source.byte_to_column(given).ok_or_else(|| {
+            let max = source.len_bytes();
+            if given <= max {
+                CodespanError::InvalidCharBoundary { given }
+            } else {
+                CodespanError::IndexTooLarge { given, max }
+            }
+        })
+    }
+}

data/ext/typst/src/download.rs

@@ -0,0 +1,19 @@
+use std::fmt::Display;
+
+use typst_kit::download::{DownloadState, Downloader, Progress};
+
+pub struct SlientDownload<T>(pub T);
+
+impl<T: Display> Progress for SlientDownload<T> {
+    fn print_start(&mut self) {}
+
+    fn print_progress(&mut self, _state: &DownloadState) {}
+
+    fn print_finish(&mut self, _state: &DownloadState) {}
+}
+
+/// Returns a new downloader.
+pub fn downloader() -> Downloader {
+    let user_agent = concat!("typst-py/", env!("CARGO_PKG_VERSION"));
+    Downloader::new(user_agent)
+}

data/ext/typst/src/fonts.rs

@@ -0,0 +1,86 @@
+use std::cell::OnceCell;
+use std::fs::{self};
+use std::path::PathBuf;
+
+use fontdb::{Database, Source};
+use typst::font::{Font, FontBook, FontInfo};
+
+/// Searches for fonts.
+pub struct FontSearcher {
+    // Metadata about all discovered fonts.
+    pub book: FontBook,
+    /// Slots that the fonts are loaded into.
+    pub fonts: Vec<FontSlot>,
+}
+
+/// Holds details about the location of a font and lazily the font itself.
+pub struct FontSlot {
+    /// The path at which the font can be found on the system.
+    path: PathBuf,
+    /// The index of the font in its collection. Zero if the path does not point
+    /// to a collection.
+    index: u32,
+    /// The lazily loaded font.
+    font: OnceCell<Option<Font>>,
+}
+
+impl FontSlot {
+    /// Get the font for this slot.
+    pub fn get(&self) -> Option<Font> {
+        self.font
+            .get_or_init(|| {
+                let data = fs::read(&self.path).ok()?.into();
+                Font::new(data, self.index)
+            })
+            .clone()
+    }
+}
+
+impl FontSearcher {
+    /// Create a new, empty system searcher.
+    pub fn new() -> Self {
+        Self {
+            book: FontBook::new(),
+            fonts: vec![],
+        }
+    }
+
+    /// Search everything that is available.
+    pub fn search(&mut self, font_dirs: &[PathBuf], font_files: &[PathBuf]) {
+        let mut db = Database::new();
+
+        // Font paths have highest priority.
+        for path in font_dirs {
+            db.load_fonts_dir(path);
+        }
+
+        // System fonts have second priority.
+        db.load_system_fonts();
+
+        for path in font_files {
+            let _ret = db.load_font_file(path).ok();
+        }
+
+        for face in db.faces() {
+            let path = match &face.source {
+                Source::File(path) | Source::SharedFile(path, _) => path,
+                // We never add binary sources to the database, so there
+                // shouln't be any.
+                Source::Binary(_) => continue,
+            };
+
+            let info = db
+                .with_face_data(face.id, FontInfo::new)
+                .expect("database must contain this font");
+
+            if let Some(info) = info {
+                self.book.push(info);
+                self.fonts.push(FontSlot {
+                    path: path.clone(),
+                    index: face.index,
+                    font: OnceCell::new(),
+                });
+            }
+        }
+    }
+}

data/ext/typst/src/lib.rs

@@ -0,0 +1,330 @@
+use std::path::PathBuf;
+
+use magnus::{define_module, function, exception, Error }; //, IntoValue};
+use magnus::{prelude::*};
+
+use std::collections::HashMap;
+use query::{query as typst_query, QueryCommand, SerializationFormat};
+use typst::foundations::{Dict, Value};
+use typst_library::Feature;
+use world::SystemWorld;
+
+mod compiler;
+mod download;
+mod query;
+mod world;
+
+fn to_html(
+    input: PathBuf,
+    root: Option<PathBuf>,
+    font_paths: Vec<PathBuf>,
+    resource_path: PathBuf,
+    ignore_system_fonts: bool,
+    sys_inputs: HashMap<String, String>,
+) -> Result<Vec<Vec<u8>>, Error> {
+    let input = input.canonicalize()
+        .map_err(|err| magnus::Error::new(exception::arg_error(), err.to_string()))?;
+
+    let root = if let Some(root) = root {
+        root.canonicalize()
+            .map_err(|err| magnus::Error::new(exception::arg_error(), err.to_string()))?
+    } else if let Some(dir) = input.parent() {
+        dir.into()
+    } else {
+        PathBuf::new()
+    };
+
+    let resource_path = resource_path.canonicalize()
+        .map_err(|err| magnus::Error::new(exception::arg_error(), err.to_string()))?;
+
+    let mut default_fonts = Vec::new();
+    for entry in walkdir::WalkDir::new(resource_path.join("fonts")) {
+        let path = entry
+            .map_err(|err| magnus::Error::new(exception::arg_error(), err.to_string()))?
+            .into_path();
+        let Some(extension) = path.extension() else {
+            continue;
+        };
+        if extension == "ttf" || extension == "otf" {
+            default_fonts.push(path);
+        }
+    }
+
+    let mut features = Vec::new();
+    features.push(Feature::Html);
+
+    let feat = features.iter()
+    .map(|&feature|
+        match feature {
+            Feature::Html => typst::Feature::Html,
+            _ => typst::Feature::Html // TODO: fix this hack
+        }
+    )
+    .collect();
+
+    let mut world = SystemWorld::builder(root, input)
+        .inputs(Dict::from_iter(
+            sys_inputs
+                .into_iter()
+                .map(|(k, v)| (k.into(), Value::Str(v.into()))),
+        ))
+        .features(feat)
+        .font_paths(font_paths)
+        .ignore_system_fonts(ignore_system_fonts)
+        .build()
+        .map_err(|msg| magnus::Error::new(exception::arg_error(), msg.to_string()))?;
+
+    let bytes = world
+        .compile(Some("html"), None, &Vec::new())
+        .map_err(|msg| magnus::Error::new(exception::arg_error(), msg.to_string()))?;
+
+    Ok(bytes)
+}
+
+fn to_svg(
+    input: PathBuf,
+    root: Option<PathBuf>,
+    font_paths: Vec<PathBuf>,
+    resource_path: PathBuf,
+    ignore_system_fonts: bool,
+    sys_inputs: HashMap<String, String>,
+) -> Result<Vec<Vec<u8>>, Error> {
+    let input = input.canonicalize()
+        .map_err(|err| magnus::Error::new(exception::arg_error(), err.to_string()))?;
+
+    let root = if let Some(root) = root {
+        root.canonicalize()
+            .map_err(|err| magnus::Error::new(exception::arg_error(), err.to_string()))?
+    } else if let Some(dir) = input.parent() {
+        dir.into()
+    } else {
+        PathBuf::new()
+    };
+
+    let resource_path = resource_path.canonicalize()
+        .map_err(|err| magnus::Error::new(exception::arg_error(), err.to_string()))?;
+
+    let mut default_fonts = Vec::new();
+    for entry in walkdir::WalkDir::new(resource_path.join("fonts")) {
+        let path = entry
+            .map_err(|err| magnus::Error::new(exception::arg_error(), err.to_string()))?
+            .into_path();
+        let Some(extension) = path.extension() else {
+            continue;
+        };
+        if extension == "ttf" || extension == "otf" {
+            default_fonts.push(path);
+        }
+    }
+
+    let mut world = SystemWorld::builder(root, input)
+        .inputs(Dict::from_iter(
+            sys_inputs
+                .into_iter()
+                .map(|(k, v)| (k.into(), Value::Str(v.into()))),
+        ))
+        .font_paths(font_paths)
+        .ignore_system_fonts(ignore_system_fonts)
+        .build()
+        .map_err(|msg| magnus::Error::new(exception::arg_error(), msg.to_string()))?;
+
+    let svg_bytes = world
+        .compile(Some("svg"), None, &Vec::new())
+        .map_err(|msg| magnus::Error::new(exception::arg_error(), msg.to_string()))?;
+
+    Ok(svg_bytes)
+}
+
+fn to_png(
+    input: PathBuf,
+    root: Option<PathBuf>,
+    font_paths: Vec<PathBuf>,
+    resource_path: PathBuf,
+    ignore_system_fonts: bool,
+    sys_inputs: HashMap<String, String>,
+) -> Result<Vec<Vec<u8>>, Error> {
+    let input = input.canonicalize()
+        .map_err(|err| magnus::Error::new(exception::arg_error(), err.to_string()))?;
+
+    let root = if let Some(root) = root {
+        root.canonicalize()
+            .map_err(|err| magnus::Error::new(exception::arg_error(), err.to_string()))?
+    } else if let Some(dir) = input.parent() {
+        dir.into()
+    } else {
+        PathBuf::new()
+    };
+
+    let resource_path = resource_path.canonicalize()
+        .map_err(|err| magnus::Error::new(exception::arg_error(), err.to_string()))?;
+
+    let mut default_fonts = Vec::new();
+    for entry in walkdir::WalkDir::new(resource_path.join("fonts")) {
+        let path = entry
+            .map_err(|err| magnus::Error::new(exception::arg_error(), err.to_string()))?
+            .into_path();
+        let Some(extension) = path.extension() else {
+            continue;
+        };
+        if extension == "ttf" || extension == "otf" {
+            default_fonts.push(path);
+        }
+    }
+
+    let mut world = SystemWorld::builder(root, input)
+        .inputs(Dict::from_iter(
+            sys_inputs
+                .into_iter()
+                .map(|(k, v)| (k.into(), Value::Str(v.into()))),
+        ))
+        .font_paths(font_paths)
+        .ignore_system_fonts(ignore_system_fonts)
+        .build()
+        .map_err(|msg| magnus::Error::new(exception::arg_error(), msg.to_string()))?;
+
+    let bytes = world
+        .compile(Some("png"), None, &Vec::new())
+        .map_err(|msg| magnus::Error::new(exception::arg_error(), msg.to_string()))?;
+
+    Ok(bytes)
+}
+
+fn to_pdf(
+    input: PathBuf,
+    root: Option<PathBuf>,
+    font_paths: Vec<PathBuf>,
+    resource_path: PathBuf,
+    ignore_system_fonts: bool,
+    sys_inputs: HashMap<String, String>,
+) -> Result<Vec<Vec<u8>>, Error> {
+    let input = input.canonicalize()
+        .map_err(|err| magnus::Error::new(exception::arg_error(), err.to_string()))?;
+
+    let root = if let Some(root) = root {
+        root.canonicalize()
+            .map_err(|err| magnus::Error::new(exception::arg_error(), err.to_string()))?
+    } else if let Some(dir) = input.parent() {
+        dir.into()
+    } else {
+        PathBuf::new()
+    };
+
+    let resource_path = resource_path.canonicalize()
+        .map_err(|err| magnus::Error::new(exception::arg_error(), err.to_string()))?;
+
+    let mut default_fonts = Vec::new();
+    for entry in walkdir::WalkDir::new(resource_path.join("fonts")) {
+        let path = entry
+            .map_err(|err| magnus::Error::new(exception::arg_error(), err.to_string()))?
+            .into_path();
+        let Some(extension) = path.extension() else {
+            continue;
+        };
+        if extension == "ttf" || extension == "otf" {
+            default_fonts.push(path);
+        }
+    }
+
+    let mut world = SystemWorld::builder(root, input)
+        .inputs(Dict::from_iter(
+            sys_inputs
+                .into_iter()
+                .map(|(k, v)| (k.into(), Value::Str(v.into()))),
+        ))
+        .font_paths(font_paths)
+        .ignore_system_fonts(ignore_system_fonts)
+        .build()
+        .map_err(|msg| magnus::Error::new(exception::arg_error(), msg.to_string()))?;
+
+    let pdf_bytes = world
+        .compile(Some("pdf"), None, &Vec::new())
+        .map_err(|msg| magnus::Error::new(exception::arg_error(), msg.to_string()))?;
+
+    Ok(pdf_bytes)
+}
+
+fn query(
+    selector: String,
+    field: Option<String>,
+    one: bool,
+    format: Option<String>,
+    input: PathBuf,
+    root: Option<PathBuf>,
+    font_paths: Vec<PathBuf>,
+    resource_path: PathBuf,
+    ignore_system_fonts: bool,
+    sys_inputs: HashMap<String, String>,
+) -> Result<String, Error> {
+    let format = match format.unwrap().to_ascii_lowercase().as_str() {
+        "json" => SerializationFormat::Json,
+        "yaml" => SerializationFormat::Yaml,
+        _ => return Err(magnus::Error::new(exception::arg_error(), "unsupported serialization format"))?,
+    };
+
+    let input = input.canonicalize()
+        .map_err(|err| magnus::Error::new(exception::arg_error(), err.to_string()))?;
+
+    let root = if let Some(root) = root {
+        root.canonicalize()
+            .map_err(|err| magnus::Error::new(exception::arg_error(), err.to_string()))?
+    } else if let Some(dir) = input.parent() {
+        dir.into()
+    } else {
+        PathBuf::new()
+    };
+
+    let resource_path = resource_path.canonicalize()
+        .map_err(|err| magnus::Error::new(exception::arg_error(), err.to_string()))?;
+
+    let mut default_fonts = Vec::new();
+    for entry in walkdir::WalkDir::new(resource_path.join("fonts")) {
+        let path = entry
+            .map_err(|err| magnus::Error::new(exception::arg_error(), err.to_string()))?
+            .into_path();
+        let Some(extension) = path.extension() else {
+            continue;
+        };
+        if extension == "ttf" || extension == "otf" {
+            default_fonts.push(path);
+        }
+    }
+
+    let mut world = SystemWorld::builder(root, input)
+    .inputs(Dict::from_iter(
+        sys_inputs
+            .into_iter()
+            .map(|(k, v)| (k.into(), Value::Str(v.into()))),
+    ))
+    .font_paths(font_paths)
+    .ignore_system_fonts(ignore_system_fonts)
+    .build()
+    .map_err(|msg| magnus::Error::new(exception::arg_error(), msg.to_string()))?;
+
+    let result = typst_query(
+        &mut world,
+        &QueryCommand {
+            selector: selector.into(),
+            field: field.map(Into::into),
+            one,
+            format,
+        },
+    );
+
+    match result {
+        Ok(data) => Ok(data),
+        Err(msg) => Err(magnus::Error::new(exception::arg_error(), msg.to_string())),
+    }
+}
+
+#[magnus::init]
+fn init() -> Result<(), Error> {
+    env_logger::init();
+
+    let module = define_module("Typst")?;
+    module.define_singleton_method("_to_pdf", function!(to_pdf, 6))?;
+    module.define_singleton_method("_to_svg", function!(to_svg, 6))?;
+    module.define_singleton_method("_to_png", function!(to_png, 6))?;
+    module.define_singleton_method("_to_html", function!(to_html, 6))?;
+    module.define_singleton_method("_query", function!(query, 10))?;
+    Ok(())
+}