Struct typst_as_lib::TypstTemplateCollection

pub struct TypstTemplateCollection<'a> { /* private fields */ }

Implementations

impl<'a> TypstTemplateCollection<'a>

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

where V: Into<Vec<Font>>,

Initialize with fonts.

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])
    .with_static_file_resolver([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 custom_inject_location_mut<S>(&mut self, module_name: S, value_name: S)

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_fonts_mut<I, F>(&mut self, fonts: I) -> &mut 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 + 'a,

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 add_file_resolver_mut<F>(&mut self, file_resolver: F)

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

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 StaticSourceFileResolver 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_source_file_resolver_mut<IS, S>(&mut self, sources: IS)

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

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

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_static_file_resolver_mut<IB, F, B>(&mut self, binaries: IB)

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 FileSystemResolver to the file resolvers, a resolver that can resolve local files (when package is not set in FileId).

pub fn with_file_system_resolver_mut<P>(&mut self, root: P)

where P: Into<PathBuf>,

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

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

where F: Into<FileIdNewType>, 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.

Example:

static TEMPLATE: &str = include_str!("./templates/template.typ");
static FONT: &[u8] = include_bytes!("./fonts/texgyrecursor-regular.otf");
static TEMPLATE_ID: &str = "/template.typ";
// ...
let font = Font::new(Bytes::from(FONT), 0).expect("Could not parse font!");
let template_collection = TypstTemplateCollection::new(vec![font])
    .add_static_file_resolver([(TEMPLATE_ID, TEMPLATE)]);
// Struct that implements Into<Dict>.
let inputs = todo!();
let tracer = Default::default();
let doc = template_collection.compile_with_inputs(&mut tracer, TEMPLATE_ID, inputs)
    .expect("Typst error!");

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

where F: Into<FileIdNewType>,

Just call typst::compile()

Trait Implementations

impl<'a> From<TypstTemplate<'a>> for TypstTemplateCollection<'a>

fn from(value: TypstTemplate<'a>) -> Self

Converts to this type from the input type.