caisin/typst
1
0
Fork 0
mirror of https://github.com/typst/typst synced 2025-08-15 07:28:32 +08:00
Code Issues Packages Projects Releases Wiki Activity

Fix compile errors

Browse Source
This commit is contained in:
Laurenz Stampfl 2025-03-16 22:12:37 +01:00
parent bb7efcccec
commit abcd0822f8
9 changed files with 54 additions and 58 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
crates/typst-pdf/src/convert.rs
View File

@ -2,14 +2,14 @@ use std::collections::{BTreeMap, HashMap, HashSet};
use std::num::NonZeroU64; use std::num::NonZeroU64;
use ecow::EcoVec; use ecow::EcoVec;
use krilla::annotation::Annotation;
use krilla::destination::{NamedDestination, XyzDestination};
use krilla::embed::EmbedError;
use krilla::error::KrillaError; use krilla::error::KrillaError;
use krilla::page::PageLabel; use krilla::page::PageLabel;
use krilla::path::PathBuilder; use krilla::path::PathBuilder;
use krilla::surface::Surface; use krilla::surface::Surface;
use krilla::{Configuration, Document, PageSettings, SerializeSettings, ValidationError}; use krilla::{Configuration, Document, PageSettings, SerializeSettings, ValidationError};
use krilla::interactive::annotation::Annotation;
use krilla::interactive::destination::{NamedDestination, XyzDestination};
use krilla::interchange::embed::EmbedError;
use krilla_svg::render_svg_glyph; use krilla_svg::render_svg_glyph;
use typst_library::diag::{bail, error, SourceResult}; use typst_library::diag::{bail, error, SourceResult};
use typst_library::foundations::NativeElement; use typst_library::foundations::NativeElement;
@ -208,13 +208,13 @@ impl FrameContext {
/// Globally needed context for converting a typst document. /// Globally needed context for converting a typst document.
pub(crate) struct GlobalContext<'a> { pub(crate) struct GlobalContext<'a> {
/// Cache the conversion between krilla and Typst fonts (forward and backward). /// Cache the conversion between krilla and Typst fonts (forward and backward).
pub(crate) fonts_forward: HashMap<Font, krilla::font::Font>, pub(crate) fonts_forward: HashMap<Font, krilla::text::Font>,
pub(crate) fonts_backward: HashMap<krilla::font::Font, Font>, pub(crate) fonts_backward: HashMap<krilla::text::Font, Font>,
/// Mapping between images and their span. /// Mapping between images and their span.
// Note: In theory, the same image can have multiple spans // Note: In theory, the same image can have multiple spans
// if it appears in the document multiple times. We just store the // if it appears in the document multiple times. We just store the
// first appearance, though. // first appearance, though.
pub(crate) image_to_spans: HashMap<krilla::image::Image, Span>, pub(crate) image_to_spans: HashMap<krilla::graphics::image::Image, Span>,
pub(crate) image_spans: HashSet<Span>, pub(crate) image_spans: HashSet<Span>,
pub(crate) document: &'a PagedDocument, pub(crate) document: &'a PagedDocument,
pub(crate) options: &'a PdfOptions<'a>, pub(crate) options: &'a PdfOptions<'a>,
@ -311,7 +311,7 @@ pub(crate) fn handle_group(
.and_then(|p| p.transform(fc.state().transform.to_krilla())); .and_then(|p| p.transform(fc.state().transform.to_krilla()));
if let Some(clip_path) = &clip_path { if let Some(clip_path) = &clip_path {
surface.push_clip_path(clip_path, &krilla::path::FillRule::NonZero); surface.push_clip_path(clip_path, &krilla::graphics::paint::FillRule::NonZero);
} }
handle_frame(fc, &group.frame, None, surface, context)?; handle_frame(fc, &group.frame, None, surface, context)?;
@ -336,18 +336,14 @@ fn finish(document: Document, gc: GlobalContext) -> SourceResult<Vec<u8>> {
match document.finish() { match document.finish() {
Ok(r) => Ok(r), Ok(r) => Ok(r),
Err(e) => match e { Err(e) => match e {
KrillaError::FontError(f, s) => { KrillaError::Font(f, s) => {
let font_str = display_font(gc.fonts_backward.get(&f).unwrap()); let font_str = display_font(gc.fonts_backward.get(&f).unwrap());
bail!(Span::detached(), "failed to process font {font_str} ({s})"; bail!(Span::detached(), "failed to process font {font_str} ({s})";
hint: "make sure the font is valid"; hint: "make sure the font is valid";
hint: "this could also be a bug in the Typst compiler" hint: "this could also be a bug in the Typst compiler"
); );
} }
KrillaError::UserError(u) => { KrillaError::Validation(ve) => {
// This is an error which indicates misuse on the typst-pdf side.
bail!(Span::detached(), "internal error ({u})"; hint: "please report this as a bug")
}
KrillaError::ValidationError(ve) => {
// We can only produce 1 error, so just take the first one. // We can only produce 1 error, so just take the first one.
let prefix = let prefix =
format!("validated export with {} failed:", validator.as_str()); format!("validated export with {} failed:", validator.as_str());
@ -503,7 +499,7 @@ fn finish(document: Document, gc: GlobalContext) -> SourceResult<Vec<u8>> {
Err(errors) Err(errors)
} }
KrillaError::ImageError(i) => { KrillaError::Image(i) => {
let span = gc.image_to_spans.get(&i).unwrap(); let span = gc.image_to_spans.get(&i).unwrap();
bail!(*span, "failed to process image"); bail!(*span, "failed to process image");
} }

2
crates/typst-pdf/src/embed.rs
View File

@ -1,7 +1,7 @@
use std::sync::Arc; use std::sync::Arc;
use krilla::embed::{AssociationKind, EmbeddedFile};
use krilla::Document; use krilla::Document;
use krilla::interchange::embed::{AssociationKind, EmbeddedFile};
use typst_library::diag::{bail, SourceResult}; use typst_library::diag::{bail, SourceResult};
use typst_library::foundations::{NativeElement, StyleChain}; use typst_library::foundations::{NativeElement, StyleChain};
use typst_library::layout::PagedDocument; use typst_library::layout::PagedDocument;

12
crates/typst-pdf/src/image.rs
View File

@ -2,7 +2,7 @@ use std::hash::{Hash, Hasher};
use std::sync::{Arc, OnceLock}; use std::sync::{Arc, OnceLock};
use image::{DynamicImage, EncodableLayout, GenericImageView, Rgba}; use image::{DynamicImage, EncodableLayout, GenericImageView, Rgba};
use krilla::image::{BitsPerComponent, CustomImage, ImageColorspace}; use krilla::graphics::image::{BitsPerComponent, CustomImage, ImageColorspace};
use krilla::surface::Surface; use krilla::surface::Surface;
use krilla_svg::{SurfaceExt, SvgSettings}; use krilla_svg::{SurfaceExt, SvgSettings};
use typst_library::diag::{bail, SourceResult}; use typst_library::diag::{bail, SourceResult};
@ -164,23 +164,23 @@ impl CustomImage for PdfImage {
fn convert_raster( fn convert_raster(
raster: RasterImage, raster: RasterImage,
interpolate: bool, interpolate: bool,
) -> Option<krilla::image::Image> { ) -> Option<krilla::graphics::image::Image> {
match raster.format() { match raster.format() {
RasterFormat::Exchange(e) => match e { RasterFormat::Exchange(e) => match e {
ExchangeFormat::Jpg => { ExchangeFormat::Jpg => {
if !raster.is_rotated() { if !raster.is_rotated() {
let image_data: Arc<dyn AsRef<[u8]> + Send + Sync> = let image_data: Arc<dyn AsRef<[u8]> + Send + Sync> =
Arc::new(raster.data().clone()); Arc::new(raster.data().clone());
krilla::image::Image::from_jpeg(image_data.into(), interpolate) krilla::graphics::image::Image::from_jpeg(image_data.into(), interpolate)
} else { } else {
// Can't embed original JPEG data if it had to be rotated. // Can't embed original JPEG data if it had to be rotated.
krilla::image::Image::from_custom(PdfImage::new(raster), interpolate) krilla::graphics::image::Image::from_custom(PdfImage::new(raster), interpolate)
} }
} }
_ => krilla::image::Image::from_custom(PdfImage::new(raster), interpolate), _ => krilla::graphics::image::Image::from_custom(PdfImage::new(raster), interpolate),
}, },
RasterFormat::Pixel(_) => { RasterFormat::Pixel(_) => {
krilla::image::Image::from_custom(PdfImage::new(raster), interpolate) krilla::graphics::image::Image::from_custom(PdfImage::new(raster), interpolate)
} }
} }
} }

10
crates/typst-pdf/src/link.rs
View File

@ -1,7 +1,7 @@
use krilla::action::{Action, LinkAction};
use krilla::annotation::{LinkAnnotation, Target};
use krilla::destination::XyzDestination;
use krilla::geom::Rect; use krilla::geom::Rect;
use krilla::interactive::action::{Action, LinkAction};
use krilla::interactive::annotation::{LinkAnnotation, Target};
use krilla::interactive::destination::XyzDestination;
use typst_library::layout::{Abs, Point, Size}; use typst_library::layout::{Abs, Point, Size};
use typst_library::model::Destination; use typst_library::model::Destination;
@ -65,7 +65,7 @@ pub(crate) fn handle_link(
LinkAnnotation::new( LinkAnnotation::new(
rect, rect,
None, None,
Target::Destination(krilla::destination::Destination::Named( Target::Destination(krilla::interactive::destination::Destination::Named(
nd.clone(), nd.clone(),
)), )),
) )
@ -84,7 +84,7 @@ pub(crate) fn handle_link(
LinkAnnotation::new( LinkAnnotation::new(
rect, rect,
None, None,
Target::Destination(krilla::destination::Destination::Xyz( Target::Destination(krilla::interactive::destination::Destination::Xyz(
XyzDestination::new(page_index, pos.point.to_krilla()), XyzDestination::new(page_index, pos.point.to_krilla()),
)), )),
) )

6
crates/typst-pdf/src/metadata.rs
View File

@ -1,5 +1,5 @@
use ecow::EcoString; use ecow::EcoString;
use krilla::metadata::Metadata; use krilla::interchange::metadata::Metadata;
use typst_library::foundations::{Datetime, Smart}; use typst_library::foundations::{Datetime, Smart};
use crate::convert::GlobalContext; use crate::convert::GlobalContext;
@ -53,10 +53,10 @@ pub(crate) fn build_metadata(gc: &GlobalContext) -> Metadata {
fn convert_date( fn convert_date(
datetime: Datetime, datetime: Datetime,
tz: Option<Timezone>, tz: Option<Timezone>,
) -> Option<krilla::metadata::DateTime> { ) -> Option<krilla::interchange::metadata::DateTime> {
let year = datetime.year().filter(|&y| y >= 0)? as u16; let year = datetime.year().filter(|&y| y >= 0)? as u16;
let mut kd = krilla::metadata::DateTime::new(year); let mut kd = krilla::interchange::metadata::DateTime::new(year);
if let Some(month) = datetime.month() { if let Some(month) = datetime.month() {
kd = kd.month(month); kd = kd.month(month);

5
crates/typst-pdf/src/outline.rs
View File

@ -1,7 +1,6 @@
use std::num::NonZeroUsize; use std::num::NonZeroUsize;
use krilla::interactive::destination::XyzDestination;
use krilla::destination::XyzDestination; use krilla::interchange::outline::{Outline, OutlineNode};
use krilla::outline::{Outline, OutlineNode};
use typst_library::foundations::{NativeElement, Packed, StyleChain}; use typst_library::foundations::{NativeElement, Packed, StyleChain};
use typst_library::layout::Abs; use typst_library::layout::Abs;
use typst_library::model::HeadingElem; use typst_library::model::HeadingElem;

41
crates/typst-pdf/src/paint.rs
View File

@ -1,7 +1,8 @@
//! Convert paint types from typst to krilla. //! Convert paint types from typst to krilla.
use krilla::geom::NormalizedF32; use krilla::geom::NormalizedF32;
use krilla::paint::SpreadMethod; use krilla::graphics::color::{cmyk, luma, rgb};
use krilla::graphics::paint::{Fill, LinearGradient, Pattern, RadialGradient, SpreadMethod, Stop, Stroke, StrokeDash, SweepGradient};
use krilla::surface::Surface; use krilla::surface::Surface;
use typst_library::diag::SourceResult; use typst_library::diag::SourceResult;
use typst_library::layout::{Abs, Angle, Quadrant, Ratio, Size, Transform}; use typst_library::layout::{Abs, Angle, Quadrant, Ratio, Size, Transform};
@ -22,10 +23,10 @@ pub(crate) fn convert_fill(
surface: &mut Surface, surface: &mut Surface,
state: &State, state: &State,
size: Size, size: Size,
) -> SourceResult<krilla::path::Fill> { ) -> SourceResult<Fill> {
let (paint, opacity) = convert_paint(gc, paint_, on_text, surface, state, size)?; let (paint, opacity) = convert_paint(gc, paint_, on_text, surface, state, size)?;
Ok(krilla::path::Fill { Ok(Fill {
paint, paint,
rule: fill_rule_.to_krilla(), rule: fill_rule_.to_krilla(),
opacity: NormalizedF32::new(opacity as f32 / 255.0).unwrap(), opacity: NormalizedF32::new(opacity as f32 / 255.0).unwrap(),
@ -39,11 +40,11 @@ pub(crate) fn convert_stroke(
surface: &mut Surface, surface: &mut Surface,
state: &State, state: &State,
size: Size, size: Size,
) -> SourceResult<krilla::path::Stroke> { ) -> SourceResult<Stroke> {
let (paint, opacity) = let (paint, opacity) =
convert_paint(fc, &stroke.paint, on_text, surface, state, size)?; convert_paint(fc, &stroke.paint, on_text, surface, state, size)?;
Ok(krilla::path::Stroke { Ok(Stroke {
paint, paint,
width: stroke.thickness.to_f32(), width: stroke.thickness.to_f32(),
miter_limit: stroke.miter_limit.get() as f32, miter_limit: stroke.miter_limit.get() as f32,
@ -61,7 +62,7 @@ fn convert_paint(
surface: &mut Surface, surface: &mut Surface,
state: &State, state: &State,
mut size: Size, mut size: Size,
) -> SourceResult<(krilla::paint::Paint, u8)> { ) -> SourceResult<(krilla::graphics::paint::Paint, u8)> {
// Edge cases for strokes. // Edge cases for strokes.
if size.x.is_zero() { if size.x.is_zero() {
size.x = Abs::pt(1.0); size.x = Abs::pt(1.0);
@ -78,16 +79,16 @@ fn convert_paint(
} }
} }
fn convert_solid(color: &Color) -> (krilla::paint::Paint, u8) { fn convert_solid(color: &Color) -> (krilla::graphics::paint::Paint, u8) {
match color.space() { match color.space() {
ColorSpace::D65Gray => { ColorSpace::D65Gray => {
let components = color.to_vec4_u8(); let components = color.to_vec4_u8();
(krilla::color::luma::Color::new(components[0]).into(), components[3]) (luma::Color::new(components[0]).into(), components[3])
} }
ColorSpace::Cmyk => { ColorSpace::Cmyk => {
let components = color.to_vec4_u8(); let components = color.to_vec4_u8();
( (
krilla::color::cmyk::Color::new( cmyk::Color::new(
components[0], components[0],
components[1], components[1],
components[2], components[2],
@ -112,7 +113,7 @@ fn convert_pattern(
on_text: bool, on_text: bool,
surface: &mut Surface, surface: &mut Surface,
state: &State, state: &State,
) -> SourceResult<(krilla::paint::Paint, u8)> { ) -> SourceResult<(krilla::graphics::paint::Paint, u8)> {
let transform = correct_transform(state, pattern.unwrap_relative(on_text)); let transform = correct_transform(state, pattern.unwrap_relative(on_text));
let mut stream_builder = surface.stream_builder(); let mut stream_builder = surface.stream_builder();
@ -121,7 +122,7 @@ fn convert_pattern(
handle_frame(&mut fc, pattern.frame(), None, &mut surface, gc)?; handle_frame(&mut fc, pattern.frame(), None, &mut surface, gc)?;
surface.finish(); surface.finish();
let stream = stream_builder.finish(); let stream = stream_builder.finish();
let pattern = krilla::paint::Pattern { let pattern = Pattern {
stream, stream,
transform: transform.to_krilla(), transform: transform.to_krilla(),
width: (pattern.size().x + pattern.spacing().x).to_pt() as _, width: (pattern.size().x + pattern.spacing().x).to_pt() as _,
@ -136,7 +137,7 @@ fn convert_gradient(
on_text: bool, on_text: bool,
state: &State, state: &State,
size: Size, size: Size,
) -> (krilla::paint::Paint, u8) { ) -> (krilla::graphics::paint::Paint, u8) {
let size = match gradient.unwrap_relative(on_text) { let size = match gradient.unwrap_relative(on_text) {
RelativeTo::Self_ => size, RelativeTo::Self_ => size,
RelativeTo::Parent => state.container_size(), RelativeTo::Parent => state.container_size(),
@ -163,7 +164,7 @@ fn convert_gradient(
} }
}; };
let linear = krilla::paint::LinearGradient { let linear = LinearGradient {
x1, x1,
y1, y1,
x2, x2,
@ -183,7 +184,7 @@ fn convert_gradient(
(linear.into(), 255) (linear.into(), 255)
} }
Gradient::Radial(radial) => { Gradient::Radial(radial) => {
let radial = krilla::paint::RadialGradient { let radial = RadialGradient {
fx: radial.focal_center.x.get() as f32, fx: radial.focal_center.x.get() as f32,
fy: radial.focal_center.y.get() as f32, fy: radial.focal_center.y.get() as f32,
fr: radial.focal_radius.get() as f32, fr: radial.focal_radius.get() as f32,
@ -223,7 +224,7 @@ fn convert_gradient(
Abs::pt(cy as f64), Abs::pt(cy as f64),
)); ));
let sweep = krilla::paint::SweepGradient { let sweep = SweepGradient {
cx, cx,
cy, cy,
start_angle: 0.0, start_angle: 0.0,
@ -241,14 +242,14 @@ fn convert_gradient(
fn convert_gradient_stops( fn convert_gradient_stops(
gradient: &Gradient, gradient: &Gradient,
) -> Vec<krilla::paint::Stop<krilla::color::rgb::Color>> { ) -> Vec<Stop<rgb::Color>> {
let mut stops: Vec<krilla::paint::Stop<krilla::color::rgb::Color>> = vec![]; let mut stops: Vec<Stop<rgb::Color>> = vec![];
let mut add_single = |color: &Color, offset: Ratio| { let mut add_single = |color: &Color, offset: Ratio| {
let (color, opacity) = color.to_krilla_rgb(); let (color, opacity) = color.to_krilla_rgb();
let opacity = NormalizedF32::new((opacity as f32) / 255.0).unwrap(); let opacity = NormalizedF32::new((opacity as f32) / 255.0).unwrap();
let offset = NormalizedF32::new(offset.get() as f32).unwrap(); let offset = NormalizedF32::new(offset.get() as f32).unwrap();
let stop = krilla::paint::Stop { offset, color, opacity }; let stop = Stop { offset, color, opacity };
stops.push(stop); stops.push(stop);
}; };
@ -338,8 +339,8 @@ fn convert_gradient_stops(
stops stops
} }
fn convert_dash(dash: &DashPattern<Abs, Abs>) -> krilla::path::StrokeDash { fn convert_dash(dash: &DashPattern<Abs, Abs>) -> StrokeDash {
krilla::path::StrokeDash { StrokeDash {
array: dash.array.iter().map(|e| e.to_f32()).collect(), array: dash.array.iter().map(|e| e.to_f32()).collect(),
offset: dash.phase.to_f32(), offset: dash.phase.to_f32(),
} }

8
crates/typst-pdf/src/text.rs
View File

@ -2,7 +2,7 @@ use std::ops::Range;
use std::sync::Arc; use std::sync::Arc;
use bytemuck::TransparentWrapper; use bytemuck::TransparentWrapper;
use krilla::font::GlyphId; use krilla::text::GlyphId;
use krilla::surface::{Location, Surface}; use krilla::surface::{Location, Surface};
use typst_library::diag::{bail, SourceResult}; use typst_library::diag::{bail, SourceResult};
use typst_library::layout::{Abs, Size}; use typst_library::layout::{Abs, Size};
@ -74,14 +74,14 @@ pub(crate) fn handle_text(
fn convert_font( fn convert_font(
gc: &mut GlobalContext, gc: &mut GlobalContext,
typst_font: Font, typst_font: Font,
) -> SourceResult<krilla::font::Font> { ) -> SourceResult<krilla::text::Font> {
if let Some(font) = gc.fonts_forward.get(&typst_font) { if let Some(font) = gc.fonts_forward.get(&typst_font) {
Ok(font.clone()) Ok(font.clone())
} else { } else {
let font_data: Arc<dyn AsRef<[u8]> + Send + Sync> = let font_data: Arc<dyn AsRef<[u8]> + Send + Sync> =
Arc::new(typst_font.data().clone()); Arc::new(typst_font.data().clone());
let font = let font =
match krilla::font::Font::new(font_data.into(), typst_font.index(), true) { match krilla::text::Font::new(font_data.into(), typst_font.index(), true) {
None => { None => {
let font_str = display_font(&typst_font); let font_str = display_font(&typst_font);
bail!(Span::detached(), "failed to process font {font_str}"); bail!(Span::detached(), "failed to process font {font_str}");
@ -100,7 +100,7 @@ fn convert_font(
#[repr(transparent)] #[repr(transparent)]
struct PdfGlyph(Glyph); struct PdfGlyph(Glyph);
impl krilla::font::Glyph for PdfGlyph { impl krilla::text::Glyph for PdfGlyph {
fn glyph_id(&self) -> GlyphId { fn glyph_id(&self) -> GlyphId {
GlyphId::new(self.0.id as u32) GlyphId::new(self.0.id as u32)
} }

4
crates/typst-pdf/src/util.rs
View File

@ -1,8 +1,8 @@
//! Basic utilities for converting typst types to krilla. //! Basic utilities for converting typst types to krilla.
use krilla::color::rgb as kr; use krilla::graphics::color::rgb as kr;
use krilla::geom as kg; use krilla::geom as kg;
use krilla::path as kp; use krilla::graphics::paint as kp;
use krilla::path::PathBuilder; use krilla::path::PathBuilder;
use typst_library::layout::{Abs, Point, Size, Transform}; use typst_library::layout::{Abs, Point, Size, Transform};
use typst_library::text::Font; use typst_library::text::Font;