Struct typst_as_lib::TypstTemplate

pub struct TypstTemplate { /* private fields */ }

Implementations

impl TypstTemplate

pub fn new<V, S>(fonts: V, source_id: S) -> Self

where V: Into<Vec<Font>>, S: Into<SourceNewType>,

Initialize with fonts and a source file.

source can be of types:

• &str/String, creating a detached Source (Has vpath /main.typ)
• (&str, &str/String), where &str is the absolute virtual path of the Source file.
• (typst::syntax::FileId, &str/String)
• typst::syntax::Source

(&str/String is always the template file content)

Example:

static TEMPLATE: &str = include_str!("./templates/template.typ");
static FONT: &[u8] = include_bytes!("./fonts/texgyrecursor-regular.otf");
// ...
let font = Font::new(Bytes::from(FONT), 0).expect("Could not parse font!");
let template = TypstTemplate::new(vec![font], TEMPLATE);

pub fn custom_inject_location<S>(self, module_name: S, value_name: S) -> Self

where S: Into<String>,

Use other typst location for injected inputs (instead of#import sys: inputs, where sys is the module_name and inputs is the value_name). Also preinitializes the library for better performance, if the template will be reused.

pub fn add_fonts<I, F>(self, fonts: I) -> Self

where I: IntoIterator<Item = F>, F: Into<Font>,

Add Fonts

pub fn add_file_resolver<F>(self, file_resolver: F) -> Self

where F: FileResolver + Send + Sync + 'static,

Add file resolver, that implements the FileResolver`` trait to a vec of file resolvers. When a FileId`` needs to be resolved by Typst, the vec will be iterated over until one file resolver returns a file.

pub fn with_static_source_file_resolver<IS, S>(self, sources: IS) -> Self

where IS: IntoIterator<Item = S>, S: Into<SourceNewType>,

Adds the StaticFileResolver to the file resolvers. It creates HashMaps for sources.

sources The item of the IntoIterator can be of types:

• &str/String, creating a detached Source (Has vpath /main.typ)
• (&str, &str/String), where &str is the absolute virtual path of the Source file.
• (typst::syntax::FileId, &str/String)
• typst::syntax::Source

(&str/String is always the template file content)

pub fn with_static_file_resolver<IB, F, B>(self, binaries: IB) -> Self

where IB: IntoIterator<Item = (F, B)>, F: Into<FileIdNewType>, B: Into<Bytes>,

Adds the StaticFileResolver to the file resolvers. It creates HashMaps for binaries.

pub fn with_file_system_resolver<P>(self, root: P) -> Self

where P: Into<PathBuf>,

Adds FileSystemFileResolver to the file resolvers, a resolver that can resolve local files (when package is not set in FileId).

pub fn compile_with_input<D>( &self, tracer: &mut Tracer, inputs: D, ) -> Result<Document, TypstAsLibError>

where D: Into<Dict>,

Call typst::compile() with our template and a Dict as input, that will be availible in a typst script with #import sys: inputs.

pub fn compile(&self, tracer: &mut Tracer) -> Result<Document, TypstAsLibError>

Just call typst::compile()

Trait Implementations

impl From<TypstTemplate> for TypstTemplateCollection

fn from(value: TypstTemplate) -> Self

Converts to this type from the input type.