typst 0.0.4 → 0.13.0

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(())
 }

data/ext/typst/src/query.rs

@@ -0,0 +1,131 @@
+use comemo::Track;
+use ecow::{eco_format, EcoString};
+use serde::Serialize;
+use typst::diag::{bail, StrResult, Warned};
+use typst::foundations::{Content, IntoValue, LocatableSelector, Scope};
+use typst::layout::PagedDocument;
+use typst::syntax::Span;
+use typst::World;
+use typst_eval::{eval_string, EvalMode};
+
+use crate::world::SystemWorld;
+
+/// Processes an input file to extract provided metadata
+#[derive(Debug, Clone)]
+pub struct QueryCommand {
+    /// Defines which elements to retrieve
+    pub selector: String,
+
+    /// Extracts just one field from all retrieved elements
+    pub field: Option<String>,
+
+    /// Expects and retrieves exactly one element
+    pub one: bool,
+
+    /// The format to serialize in
+    pub format: SerializationFormat,
+}
+
+// Output file format for query command
+#[derive(Debug, Copy, Clone, Eq, PartialEq)]
+pub enum SerializationFormat {
+    Json,
+    Yaml,
+}
+
+/// Execute a query command.
+pub fn query(world: &mut SystemWorld, command: &QueryCommand) -> StrResult<String> {
+    // Reset everything and ensure that the main file is present.
+    world.reset();
+    world.source(world.main()).map_err(|err| err.to_string())?;
+
+    let Warned { output, warnings } = typst::compile(world);
+
+    match output {
+        // Retrieve and print query results.
+        Ok(document) => {
+            let data = retrieve(world, command, &document)?;
+            let serialized = format(data, command)?;
+            Ok(serialized)
+        }
+        // Print errors and warnings.
+        Err(errors) => {
+            let mut message = EcoString::from("failed to compile document");
+            for (i, error) in errors.into_iter().enumerate() {
+                message.push_str(if i == 0 { ": " } else { ", " });
+                message.push_str(&error.message);
+            }
+            for warning in warnings {
+                message.push_str(": ");
+                message.push_str(&warning.message);
+            }
+            Err(message)
+        }
+    }
+}
+
+/// Retrieve the matches for the selector.
+fn retrieve(
+    world: &dyn World,
+    command: &QueryCommand,
+    document: &PagedDocument,
+) -> StrResult<Vec<Content>> {
+    let selector = eval_string(
+        &typst::ROUTINES,
+        world.track(),
+        &command.selector,
+        Span::detached(),
+        EvalMode::Code,
+        Scope::default(),
+    )
+    .map_err(|errors| {
+        let mut message = EcoString::from("failed to evaluate selector");
+        for (i, error) in errors.into_iter().enumerate() {
+            message.push_str(if i == 0 { ": " } else { ", " });
+            message.push_str(&error.message);
+        }
+        message
+    })?
+    .cast::<LocatableSelector>()
+    .map_err(|e| e.message().clone())?;
+
+    Ok(document
+        .introspector
+        .query(&selector.0)
+        .into_iter()
+        .collect::<Vec<_>>())
+}
+
+/// Format the query result in the output format.
+fn format(elements: Vec<Content>, command: &QueryCommand) -> StrResult<String> {
+    if command.one && elements.len() != 1 {
+        bail!("expected exactly one element, found {}", elements.len());
+    }
+
+    let mapped: Vec<_> = elements
+        .into_iter()
+        .filter_map(|c| match &command.field {
+            Some(field) => c.get_by_name(field).ok(),
+            _ => Some(c.into_value()),
+        })
+        .collect();
+
+    if command.one {
+        let Some(value) = mapped.first() else {
+            bail!("no such field found for element");
+        };
+        serialize(value, command.format)
+    } else {
+        serialize(&mapped, command.format)
+    }
+}
+
+/// Serialize data to the output format.
+fn serialize(data: &impl Serialize, format: SerializationFormat) -> StrResult<String> {
+    match format {
+        SerializationFormat::Json => {
+            serde_json::to_string_pretty(data).map_err(|e| eco_format!("{e}"))
+        }
+        SerializationFormat::Yaml => serde_yaml::to_string(&data).map_err(|e| eco_format!("{e}")),
+    }
+}