typst 0.0.5 → 0.13.1

data/ext/typst/src/compiler.rs

@@ -1,9 +1,11 @@
 use chrono::{Datelike, Timelike};
 use codespan_reporting::diagnostic::{Diagnostic, Label};
 use codespan_reporting::term::{self, termcolor};
-use typst::diag::{Severity, SourceDiagnostic, StrResult};
-use typst::doc::Document;
-use typst::eval::{eco_format, Datetime, Tracer};
+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};
 
@@ -13,55 +15,86 @@ type CodespanResult<T> = Result<T, CodespanError>;
 type CodespanError = codespan_reporting::files::Error;
 
 impl SystemWorld {
-    pub fn compile_pdf(&mut self) -> StrResult<Vec<u8>> {
+    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())?;
 
-        let mut tracer = Tracer::default();
-        let result = typst::compile(self, &mut tracer);
-        let warnings = tracer.warnings();
-
-        match result {
-            // Export the PDF / PNG.
-            Ok(document) => Ok(export_pdf(&document, self)?),
-            Err(errors) => Err(format_diagnostics(self, &errors, &warnings).unwrap().into()),
-        }
-    }
-
-    pub fn compile_svg(&mut self) -> StrResult<Vec<String>> {
-        // Reset everything and ensure that the main file is present.
-        self.reset();
-        self.source(self.main()).map_err(|err| err.to_string())?;
-
-        let mut tracer = Tracer::default();
-        let result = typst::compile(self, &mut tracer);
-        let warnings = tracer.warnings();
-
-        match result {
-            // Export the PDF / PNG.
-            Ok(document) => Ok(export_svg(&document)?),
-            Err(errors) => Err(format_diagnostics(self, &errors, &warnings).unwrap().into()),
+        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_pdf(document: &Document, world: &SystemWorld) -> StrResult<Vec<u8>> {
-    let ident = world.input().to_string_lossy();
-    let buffer = typst::export::pdf(document, Some(&ident), now());
+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 one or multiple SVGs.
+/// Export to a PDF.
 #[inline]
-fn export_svg(document: &Document) -> StrResult<Vec<String>> {
-    let mut buffer: Vec<String> = Vec::new();
-    for (_i, frame) in document.pages.iter().enumerate() {
-        let svg = typst::export::svg(frame);
-        buffer.push(svg.to_string())
-    }
+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)
 }
 
@@ -78,6 +111,34 @@ fn now() -> Option<Datetime> {
     )
 }
 
+/// 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,
@@ -141,7 +202,7 @@ impl<'a> codespan_reporting::files::Files<'a> for SystemWorld {
             // Try to express the path relative to the working directory.
             vpath
                 .resolve(self.root())
-                .and_then(|abs| pathdiff::diff_paths(&abs, self.workdir()))
+                .and_then(|abs| pathdiff::diff_paths(abs, self.workdir()))
                 .as_deref()
                 .unwrap_or_else(|| vpath.as_rootless_path())
                 .to_string_lossy()

data/ext/typst/src/download.rs

@@ -1,79 +1,19 @@
-use std::io::{self, ErrorKind, Read};
+use std::fmt::Display;
 
-use ureq::Response;
+use typst_kit::download::{DownloadState, Downloader, Progress};
 
-/// Download binary data and display its progress.
-#[allow(clippy::result_large_err)]
-pub fn download(url: &str) -> Result<Vec<u8>, ureq::Error> {
-    let mut builder =
-        ureq::AgentBuilder::new().user_agent(concat!("typst/{}", env!("CARGO_PKG_VERSION")));
+pub struct SlientDownload<T>(pub T);
 
-    // Get the network proxy config from the environment.
-    if let Some(proxy) = env_proxy::for_url_str(url)
-        .to_url()
-        .and_then(|url| ureq::Proxy::new(url).ok())
-    {
-        builder = builder.proxy(proxy);
-    }
+impl<T: Display> Progress for SlientDownload<T> {
+    fn print_start(&mut self) {}
 
-    let agent = builder.build();
-    let response = agent.get(url).call()?;
-    Ok(RemoteReader::from_response(response).download()?)
-}
+    fn print_progress(&mut self, _state: &DownloadState) {}
 
-/// A wrapper around [`ureq::Response`] that reads the response body in chunks
-/// over a websocket and displays statistics about its progress.
-///
-/// Downloads will _never_ fail due to statistics failing to print, print errors
-/// are silently ignored.
-struct RemoteReader {
-    reader: Box<dyn Read + Send + Sync + 'static>,
-    content_len: Option<usize>,
+    fn print_finish(&mut self, _state: &DownloadState) {}
 }
 
-impl RemoteReader {
-    /// Wraps a [`ureq::Response`] and prepares it for downloading.
-    ///
-    /// The 'Content-Length' header is used as a size hint for read
-    /// optimization, if present.
-    pub fn from_response(response: Response) -> Self {
-        let content_len: Option<usize> = response
-            .header("Content-Length")
-            .and_then(|header| header.parse().ok());
-
-        Self {
-            reader: response.into_reader(),
-            content_len,
-        }
-    }
-
-    /// Download the bodies content as raw bytes while attempting to print
-    /// download statistics to standard error. Download progress gets displayed
-    /// and updated every second.
-    ///
-    /// These statistics will never prevent a download from completing, errors
-    /// are silently ignored.
-    pub fn download(mut self) -> io::Result<Vec<u8>> {
-        let mut buffer = vec![0; 8192];
-        let mut data = match self.content_len {
-            Some(content_len) => Vec::with_capacity(content_len),
-            None => Vec::with_capacity(8192),
-        };
-
-        loop {
-            let read = match self.reader.read(&mut buffer) {
-                Ok(0) => break,
-                Ok(n) => n,
-                // If the data is not yet ready but will be available eventually
-                // keep trying until we either get an actual error, receive data
-                // or an Ok(0).
-                Err(ref e) if e.kind() == ErrorKind::Interrupted => continue,
-                Err(e) => return Err(e),
-            };
-
-            data.extend(&buffer[..read]);
-        }
-
-        Ok(data)
-    }
+/// 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/lib.rs

@@ -1,22 +1,94 @@
 use std::path::PathBuf;
 
-use magnus::{define_module, function, exception, Error, IntoValue};
+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 fonts;
-mod package;
+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,
-) -> Result<Vec<String>, Error> {
+    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()))?;
 
@@ -46,24 +118,85 @@ fn to_svg(
     }
 
     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)
-        .font_files(default_fonts)
+        .ignore_system_fonts(ignore_system_fonts)
         .build()
         .map_err(|msg| magnus::Error::new(exception::arg_error(), msg.to_string()))?;
 
     let svg_bytes = world
-        .compile_svg()
+        .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,
-) -> Result<Vec<u8>, Error> {
+    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()))?;
 
@@ -93,41 +226,105 @@ fn to_pdf(
     }
 
     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)
-        .font_files(default_fonts)
+        .ignore_system_fonts(ignore_system_fonts)
         .build()
         .map_err(|msg| magnus::Error::new(exception::arg_error(), msg.to_string()))?;
 
     let pdf_bytes = world
-        .compile_pdf()
+        .compile(Some("pdf"), None, &Vec::new())
         .map_err(|msg| magnus::Error::new(exception::arg_error(), msg.to_string()))?;
 
     Ok(pdf_bytes)
 }
 
-fn write_pdf(
+fn query(
+    selector: String,
+    field: Option<String>,
+    one: bool,
+    format: Option<String>,
     input: PathBuf,
-    output: PathBuf,
     root: Option<PathBuf>,
     font_paths: Vec<PathBuf>,
     resource_path: PathBuf,
-) -> Result<magnus::Value, Error> {
-    let pdf_bytes = to_pdf(input, root, font_paths, resource_path)?;
+    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"))?,
+    };
 
-    std::fs::write(output, pdf_bytes)
-        .map_err(|_| magnus::Error::new(exception::arg_error(), "error"))?;
+    let input = input.canonicalize()
+        .map_err(|err| magnus::Error::new(exception::arg_error(), err.to_string()))?;
 
-    let value = true.into_value();
-    Ok(value)
-}    
+    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, 4))?;
-    module.define_singleton_method("_write_pdf", function!(write_pdf, 5))?;
-    module.define_singleton_method("_to_svg", function!(to_svg, 4))?;
+    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(())
 }