use std::path::PathBuf;
use std::sync::Mutex;
use typst::foundations::{Bytes, Dict, IntoValue};
use typst::text::Font;
use typst::{World as _, WorldExt as _};
use typst_as_lib::{TypstAsLibError, TypstEngine, TypstWorld};
use crate::files::{
PackageFileList, Packages, SafeFsResolver, VirtualFiles, check_package, invalid_package,
};
use crate::{
CompileOutput, CompileReport, CompileRequest, DiagnosticsPolicy, Document, Error, Limits,
Result,
};
pub struct EngineBuilder {
root: Option<PathBuf>,
fonts: Vec<Vec<u8>>,
sources: Vec<(String, String)>,
binaries: Vec<(String, Vec<u8>)>,
packages: Vec<(String, PackageFileList)>,
limits: Limits,
cache_age: usize,
}
impl Default for EngineBuilder {
fn default() -> Self {
Self {
root: None,
fonts: Vec::new(),
sources: Vec::new(),
binaries: Vec::new(),
packages: Vec::new(),
limits: Limits::default(),
cache_age: 2,
}
}
}
impl EngineBuilder {
#[must_use]
pub fn root(mut self, root: impl Into<PathBuf>) -> Self {
self.root = Some(root.into());
self
}
#[must_use]
pub fn fonts<I, B>(mut self, fonts: I) -> Self
where
I: IntoIterator<Item = B>,
B: AsRef<[u8]>,
{
self.fonts
.extend(fonts.into_iter().map(|font| font.as_ref().to_vec()));
self
}
pub fn source(mut self, path: impl Into<String>, source: impl Into<String>) -> Result<Self> {
let path = path.into();
let source = source.into();
let probe = VirtualFiles::new(self.limits, Packages::default());
let _ = probe.apply_updates([(path.clone(), source.clone())], [])?;
self.sources.push((path, source));
Ok(self)
}
pub fn binary(mut self, path: impl Into<String>, binary: impl Into<Vec<u8>>) -> Result<Self> {
let path = path.into();
let binary = binary.into();
let probe = VirtualFiles::new(self.limits, Packages::default());
let _ = probe.apply_updates([], [(path.clone(), binary.clone())])?;
self.binaries.push((path, binary));
Ok(self)
}
pub fn package<I, P, B>(mut self, spec: &str, files: I) -> Result<Self>
where
I: IntoIterator<Item = (P, B)>,
P: Into<String>,
B: Into<Vec<u8>>,
{
let files = files
.into_iter()
.map(|(path, data)| (path.into(), data.into()))
.collect::<Vec<_>>();
let parsed = check_package(spec, &files, self.limits)?.to_string();
if self.packages.iter().any(|(known, _)| *known == parsed) {
return Err(invalid_package(parsed, "package is already registered"));
}
self.packages.push((parsed, files));
Ok(self)
}
#[must_use]
pub const fn limits(mut self, limits: Limits) -> Self {
self.limits = limits;
self
}
#[must_use]
pub const fn cache_age(mut self, compilations: usize) -> Self {
self.cache_age = compilations;
self
}
pub fn build(self) -> Result<Engine> {
Self::check_limit(
"font collection",
"font file count",
self.fonts.len(),
self.limits.max_fonts,
)?;
let mut font_bytes = 0_usize;
let mut parsed_fonts = Vec::new();
for (index, font) in self.fonts.into_iter().enumerate() {
Self::check_limit(
&format!("font {index}"),
"font file bytes",
font.len(),
self.limits.max_font_bytes,
)?;
font_bytes = font_bytes.saturating_add(font.len());
Self::check_limit(
"font collection",
"total font bytes",
font_bytes,
self.limits.max_total_font_bytes,
)?;
let previous_faces = parsed_fonts.len();
for parsed in Font::iter(Bytes::new(font)) {
parsed_fonts.push(parsed);
Self::check_limit(
"font collection",
"parsed font count",
parsed_fonts.len(),
self.limits.max_fonts,
)?;
}
if parsed_fonts.len() == previous_faces {
return Err(Error::InvalidFont { index });
}
}
if parsed_fonts.is_empty() {
return Err(Error::NoValidFont);
}
let packages = Packages::new(self.packages, self.limits)?;
let virtual_files = VirtualFiles::new(self.limits, packages.clone());
let _ = virtual_files.apply_updates(self.sources, self.binaries)?;
let fs_resolver = self
.root
.as_deref()
.map(|root| SafeFsResolver::new(root, self.limits, packages))
.transpose()?;
let mut builder = TypstEngine::builder()
.fonts(parsed_fonts)
.add_file_resolver(virtual_files.clone());
if let Some(resolver) = &fs_resolver {
builder = builder.add_file_resolver(resolver.clone());
}
builder.comemo_evict_max_age(Some(self.cache_age));
Ok(Engine {
inner: builder.build(),
virtual_files,
fs_resolver,
compile_lock: Mutex::new(()),
limits: self.limits,
})
}
fn check_limit(
resource: &str,
limit_name: &'static str,
actual: usize,
maximum: usize,
) -> Result<()> {
if actual > maximum {
return Err(Error::Limit {
resource: resource.to_owned(),
limit_name,
actual,
maximum,
});
}
Ok(())
}
}
pub struct Engine {
inner: TypstEngine,
virtual_files: VirtualFiles,
fs_resolver: Option<SafeFsResolver>,
compile_lock: Mutex<()>,
limits: Limits,
}
impl Engine {
#[must_use]
pub fn builder() -> EngineBuilder {
EngineBuilder::default()
}
pub fn compile(&self, request: CompileRequest) -> Result<CompileOutput> {
self.compile_tracked(request).result
}
pub fn compile_tracked(&self, request: CompileRequest) -> CompileReport {
let Ok(_guard) = self.compile_lock.lock() else {
return CompileReport {
result: Err(Error::Poisoned),
dependencies: Vec::new(),
};
};
if let Some(resolver) = &self.fs_resolver
&& let Err(error) = resolver.reset()
{
return CompileReport {
result: Err(error),
dependencies: Vec::new(),
};
}
let result = self.compile_request(request);
let dependencies = self
.fs_resolver
.as_ref()
.map(SafeFsResolver::dependencies)
.transpose();
match dependencies {
Ok(paths) => CompileReport {
result,
dependencies: paths.unwrap_or_default(),
},
Err(error) => CompileReport {
result: Err(error),
dependencies: Vec::new(),
},
}
}
fn compile_request(&self, request: CompileRequest) -> Result<CompileOutput> {
Self::check_size(
&request.source,
"path bytes",
request.source.len(),
self.limits.max_path_bytes,
)?;
Self::check_size(
&request.source,
"input count",
request.inputs.len(),
self.limits.max_inputs,
)?;
let input_bytes = request
.inputs
.iter()
.map(|(key, value)| key.len().saturating_add(value.len()))
.fold(0_usize, usize::saturating_add);
Self::check_size(
&request.source,
"input bytes",
input_bytes,
self.limits.max_input_bytes,
)?;
let snapshot = self
.virtual_files
.apply_updates(request.sources, request.binaries)?;
let mut inputs = Dict::new();
for (key, value) in &request.inputs {
inputs.insert(key.as_str().into(), value.clone().into_value());
}
let result = (|| {
let compiled = self
.inner
.compile_with_input::<_, _, Document>(request.source.as_str(), inputs);
let warnings =
format_diagnostics(&self.inner, request.source.as_str(), &compiled.warnings);
if request.diagnostics == DiagnosticsPolicy::DenyWarnings && !warnings.is_empty() {
return Err(Error::Warnings {
document: request.source.clone(),
diagnostics: warnings.join("; "),
});
}
let document = compiled.output.map_err(|error| Error::Compile {
document: request.source.clone(),
diagnostics: format_compile_error(&self.inner, request.source.as_str(), &error),
})?;
let actual = document.pages().len();
if !request.pages.accepts(actual, self.limits.max_pages) {
return Err(Error::PageCount {
document: request.source.clone(),
actual,
expected: request.pages.describe(self.limits.max_pages),
});
}
Ok(CompileOutput { document, warnings })
})();
if let Some(snapshot) = snapshot {
self.virtual_files.restore(snapshot)?;
}
result
}
#[cfg(feature = "pdf")]
pub(crate) fn check_pdf_size(&self, bytes: usize) -> Result<()> {
Self::check_size("PDF", "PDF bytes", bytes, self.limits.max_pdf_bytes)
}
#[cfg(feature = "raster")]
pub(crate) fn check_raster_size(&self, pixels: usize) -> Result<()> {
Self::check_size(
"raster page",
"raster pixels",
pixels,
self.limits.max_raster_pixels,
)
}
fn check_size(
resource: &str,
limit_name: &'static str,
actual: usize,
maximum: usize,
) -> Result<()> {
if actual > maximum {
return Err(Error::Limit {
resource: resource.to_owned(),
limit_name,
actual,
maximum,
});
}
Ok(())
}
}
fn format_compile_error(engine: &TypstEngine, source: &str, error: &TypstAsLibError) -> String {
match error {
TypstAsLibError::TypstSource(diagnostics) => {
format_diagnostics(engine, source, diagnostics).join("; ")
}
_ => error.to_string(),
}
}
fn format_diagnostics(
engine: &TypstEngine,
source: &str,
diagnostics: &[typst::diag::SourceDiagnostic],
) -> Vec<String> {
engine
.with_world(source, |world| {
diagnostics
.iter()
.map(|diagnostic| format_diagnostic(world, diagnostic))
.collect::<Vec<_>>()
})
.unwrap_or_else(|_| {
diagnostics
.iter()
.map(|diagnostic| diagnostic.message.as_str().to_owned())
.collect()
})
}
fn format_diagnostic(world: &TypstWorld<'_>, diagnostic: &typst::diag::SourceDiagnostic) -> String {
let message = diagnostic.message.as_str();
let Some(id) = diagnostic.span.id() else {
return message.to_owned();
};
let rooted = id.get();
let file = match rooted.root() {
typst::syntax::VirtualRoot::Project => rooted.vpath().get_without_slash().to_owned(),
typst::syntax::VirtualRoot::Package(spec) => {
format!("{spec}{}", rooted.vpath().get_with_slash())
}
};
let line = world.range(diagnostic.span).and_then(|range| {
let text = world.source(id).ok()?;
let prefix = text.text().get(..range.start.min(text.text().len()))?;
Some(prefix.split('\n').count())
});
match line {
Some(line) => format!("{message} ({file}:{line})"),
None => format!("{message} ({file})"),
}
}