caisin/typst
1
0
Fork 0
mirror of https://github.com/typst/typst synced 2025-08-18 17:08:33 +08:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'typst:main' into main

Browse Source
This commit is contained in:
Said A. 2025-07-04 16:10:45 +02:00 committed by GitHub
commit d2747b457f
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
31 changed files with 722 additions and 295 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
README.md
View File

@ -240,6 +240,26 @@ instant preview. To achieve these goals, we follow three core design principles:
Luckily we have [`comemo`], a system for incremental compilation which does
most of the hard work in the background.
## Acknowledgements
We'd like to thank everyone who is supporting Typst's development, be it via
[GitHub sponsors] or elsewhere. In particular, special thanks[^1] go to:
- [Posit](https://posit.co/blog/posit-and-typst/) for financing a full-time
compiler engineer
- [NLnet](https://nlnet.nl/) for supporting work on Typst via multiple grants
through the [NGI Zero Core](https://nlnet.nl/core) fund:
- Work on [HTML export](https://nlnet.nl/project/Typst-HTML/)
- Work on [PDF accessibility](https://nlnet.nl/project/Typst-Accessibility/)
- [Science & Startups](https://www.science-startups.berlin/) for having financed
Typst development from January through June 2023 via the Berlin Startup
Scholarship
- [Zerodha](https://zerodha.tech/blog/1-5-million-pdfs-in-25-minutes/) for their
generous one-time sponsorship
[^1]: This list only includes contributions for our open-source work that exceed
or are expected to exceed €10K.
[docs]: https://typst.app/docs/
[app]: https://typst.app/
[discord]: https://discord.gg/2uDybryKPe
@ -259,3 +279,4 @@ instant preview. To achieve these goals, we follow three core design principles:
[packages]: https://github.com/typst/packages/
[`comemo`]: https://github.com/typst/comemo/
[snap]: https://snapcraft.io/typst
[GitHub sponsors]: https://github.com/sponsors/typst/

2
crates/typst-cli/src/args.rs
View File

@ -491,7 +491,7 @@ pub enum PdfStandard {
/// PDF/A-2u.
#[value(name = "a-2u")]
A_2u,
/// PDF/A-3u.
/// PDF/A-3b.
#[value(name = "a-3b")]
A_3b,
/// PDF/A-3u.

4
crates/typst-layout/src/inline/collect.rs
View File

@ -206,7 +206,7 @@ pub fn collect<'a>(
}
InlineItem::Frame(mut frame) => {
frame.modify(&FrameModifiers::get_in(styles));
apply_baseline_shift(&mut frame, styles);
apply_shift(&engine.world, &mut frame, styles);
collector.push_item(Item::Frame(frame));
}
}
@ -221,7 +221,7 @@ pub fn collect<'a>(
let mut frame = layout_and_modify(styles, |styles| {
layout_box(elem, engine, loc, styles, region)
})?;
apply_baseline_shift(&mut frame, styles);
apply_shift(&engine.world, &mut frame, styles);
collector.push_item(Item::Frame(frame));
}
} else if let Some(elem) = child.to_packed::<TagElem>() {

43
crates/typst-layout/src/inline/line.rs
View File

@ -5,7 +5,7 @@ use typst_library::engine::Engine;
use typst_library::introspection::{SplitLocator, Tag};
use typst_library::layout::{Abs, Dir, Em, Fr, Frame, FrameItem, Point};
use typst_library::model::ParLineMarker;
use typst_library::text::{Lang, TextElem};
use typst_library::text::{variant, Lang, TextElem};
use typst_utils::Numeric;
use super::*;
@ -330,7 +330,7 @@ fn adjust_cj_at_line_start(p: &Preparation, items: &mut Items) {
let glyph = shaped.glyphs.to_mut().first_mut().unwrap();
let shrink = glyph.shrinkability().0;
glyph.shrink_left(shrink);
shaped.width -= shrink.at(shaped.size);
shaped.width -= shrink.at(glyph.size);
} else if p.config.cjk_latin_spacing
&& glyph.is_cj_script()
&& glyph.x_offset > Em::zero()
@ -342,7 +342,7 @@ fn adjust_cj_at_line_start(p: &Preparation, items: &mut Items) {
glyph.x_advance -= shrink;
glyph.x_offset = Em::zero();
glyph.adjustability.shrinkability.0 = Em::zero();
shaped.width -= shrink.at(shaped.size);
shaped.width -= shrink.at(glyph.size);
}
}
@ -360,7 +360,7 @@ fn adjust_cj_at_line_end(p: &Preparation, items: &mut Items) {
let shrink = glyph.shrinkability().1;
let punct = shaped.glyphs.to_mut().last_mut().unwrap();
punct.shrink_right(shrink);
shaped.width -= shrink.at(shaped.size);
shaped.width -= shrink.at(punct.size);
} else if p.config.cjk_latin_spacing
&& glyph.is_cj_script()
&& (glyph.x_advance - glyph.x_offset) > Em::one()
@ -371,7 +371,7 @@ fn adjust_cj_at_line_end(p: &Preparation, items: &mut Items) {
let glyph = shaped.glyphs.to_mut().last_mut().unwrap();
glyph.x_advance -= shrink;
glyph.adjustability.shrinkability.1 = Em::zero();
shaped.width -= shrink.at(shaped.size);
shaped.width -= shrink.at(glyph.size);
}
}
@ -412,9 +412,30 @@ fn should_repeat_hyphen(pred_line: &Line, text: &str) -> bool {
}
}
/// Apply the current baseline shift to a frame.
pub fn apply_baseline_shift(frame: &mut Frame, styles: StyleChain) {
frame.translate(Point::with_y(TextElem::baseline_in(styles)));
/// Apply the current baseline shift and italic compensation to a frame.
pub fn apply_shift<'a>(
world: &Tracked<'a, dyn World + 'a>,
frame: &mut Frame,
styles: StyleChain,
) {
let mut baseline = TextElem::baseline_in(styles);
let mut compensation = Abs::zero();
if let Some(scripts) = TextElem::shift_settings_in(styles) {
let font_metrics = TextElem::font_in(styles)
.into_iter()
.find_map(|family| {
world
.book()
.select(family.as_str(), variant(styles))
.and_then(|id| world.font(id))
})
.map_or(*scripts.kind.default_metrics(), |f| {
*scripts.kind.read_metrics(f.metrics())
});
baseline -= scripts.shift.unwrap_or(font_metrics.vertical_offset).resolve(styles);
compensation += font_metrics.horizontal_offset.resolve(styles);
}
frame.translate(Point::new(compensation, baseline));
}
/// Commit to a line and build its frame.
@ -444,7 +465,7 @@ pub fn commit(
&& TextElem::overhang_in(text.styles)
&& (line.items.len() > 1 || text.glyphs.len() > 1)
{
let amount = overhang(glyph.c) * glyph.x_advance.at(text.size);
let amount = overhang(glyph.c) * glyph.x_advance.at(glyph.size);
offset -= amount;
remaining += amount;
}
@ -458,7 +479,7 @@ pub fn commit(
&& TextElem::overhang_in(text.styles)
&& (line.items.len() > 1 || text.glyphs.len() > 1)
{
let amount = overhang(glyph.c) * glyph.x_advance.at(text.size);
let amount = overhang(glyph.c) * glyph.x_advance.at(glyph.size);
remaining += amount;
}
}
@ -519,7 +540,7 @@ pub fn commit(
let mut frame = layout_and_modify(*styles, |styles| {
layout_box(elem, engine, loc.relayout(), styles, region)
})?;
apply_baseline_shift(&mut frame, *styles);
apply_shift(&engine.world, &mut frame, *styles);
push(&mut offset, frame, idx);
} else {
offset += amount;

6
crates/typst-layout/src/inline/linebreak.rs
View File

@ -927,9 +927,9 @@ impl Estimates {
let byte_len = g.range.len();
let stretch = g.stretchability().0 + g.stretchability().1;
let shrink = g.shrinkability().0 + g.shrinkability().1;
widths.push(byte_len, g.x_advance.at(shaped.size));
stretchability.push(byte_len, stretch.at(shaped.size));
shrinkability.push(byte_len, shrink.at(shaped.size));
widths.push(byte_len, g.x_advance.at(g.size));
stretchability.push(byte_len, stretch.at(g.size));
shrinkability.push(byte_len, shrink.at(g.size));
justifiables.push(byte_len, g.is_justifiable() as usize);
}
} else {

2
crates/typst-layout/src/inline/mod.rs
View File

@ -29,7 +29,7 @@ use typst_utils::{Numeric, SliceExt};
use self::collect::{collect, Item, Segment, SpanMapper};
use self::deco::decorate;
use self::finalize::finalize;
use self::line::{apply_baseline_shift, commit, line, Line};
use self::line::{apply_shift, commit, line, Line};
use self::linebreak::{linebreak, Breakpoint};
use self::prepare::{prepare, Preparation};
use self::shaping::{

4
crates/typst-layout/src/inline/prepare.rs
View File

@ -144,7 +144,7 @@ fn add_cjk_latin_spacing(items: &mut [(Range, Item)]) {
// The spacing is default to 1/4 em, and can be shrunk to 1/8 em.
glyph.x_advance += Em::new(0.25);
glyph.adjustability.shrinkability.1 += Em::new(0.125);
text.width += Em::new(0.25).at(text.size);
text.width += Em::new(0.25).at(glyph.size);
}
// Case 2: Latin followed by a CJ character
@ -152,7 +152,7 @@ fn add_cjk_latin_spacing(items: &mut [(Range, Item)]) {
glyph.x_advance += Em::new(0.25);
glyph.x_offset += Em::new(0.25);
glyph.adjustability.shrinkability.0 += Em::new(0.125);
text.width += Em::new(0.25).at(text.size);
text.width += Em::new(0.25).at(glyph.size);
}
prev = Some(glyph);

143
crates/typst-layout/src/inline/shaping.rs
View File

@ -3,14 +3,15 @@ use std::fmt::{self, Debug, Formatter};
use std::sync::Arc;
use az::SaturatingAs;
use rustybuzz::{BufferFlags, ShapePlan, UnicodeBuffer};
use rustybuzz::{BufferFlags, Feature, ShapePlan, UnicodeBuffer};
use ttf_parser::gsub::SubstitutionSubtable;
use ttf_parser::Tag;
use typst_library::engine::Engine;
use typst_library::foundations::{Smart, StyleChain};
use typst_library::layout::{Abs, Dir, Em, Frame, FrameItem, Point, Size};
use typst_library::text::{
families, features, is_default_ignorable, language, variant, Font, FontFamily,
FontVariant, Glyph, Lang, Region, TextEdgeBounds, TextElem, TextItem,
FontVariant, Glyph, Lang, Region, ShiftSettings, TextEdgeBounds, TextElem, TextItem,
};
use typst_library::World;
use typst_utils::SliceExt;
@ -41,8 +42,6 @@ pub struct ShapedText<'a> {
pub styles: StyleChain<'a>,
/// The font variant.
pub variant: FontVariant,
/// The font size.
pub size: Abs,
/// The width of the text's bounding box.
pub width: Abs,
/// The shaped glyphs.
@ -62,6 +61,8 @@ pub struct ShapedGlyph {
pub x_offset: Em,
/// The vertical offset of the glyph.
pub y_offset: Em,
/// The font size for the glyph.
pub size: Abs,
/// The adjustability of the glyph.
pub adjustability: Adjustability,
/// The byte range of this glyph's cluster in the full inline layout. A
@ -222,14 +223,17 @@ impl<'a> ShapedText<'a> {
let mut frame = Frame::soft(size);
frame.set_baseline(top);
let size = TextElem::size_in(self.styles);
let shift = TextElem::baseline_in(self.styles);
let decos = TextElem::deco_in(self.styles);
let fill = TextElem::fill_in(self.styles);
let stroke = TextElem::stroke_in(self.styles);
let span_offset = TextElem::span_offset_in(self.styles);
for ((font, y_offset), group) in
self.glyphs.as_ref().group_by_key(|g| (g.font.clone(), g.y_offset))
for ((font, y_offset, glyph_size), group) in self
.glyphs
.as_ref()
.group_by_key(|g| (g.font.clone(), g.y_offset, g.size))
{
let mut range = group[0].range.clone();
for glyph in group {
@ -237,7 +241,7 @@ impl<'a> ShapedText<'a> {
range.end = range.end.max(glyph.range.end);
}
let pos = Point::new(offset, top + shift - y_offset.at(self.size));
let pos = Point::new(offset, top + shift - y_offset.at(size));
let glyphs: Vec<Glyph> = group
.iter()
.map(|shaped: &ShapedGlyph| {
@ -257,11 +261,11 @@ impl<'a> ShapedText<'a> {
adjustability_right * justification_ratio;
if shaped.is_justifiable() {
justification_right +=
Em::from_length(extra_justification, self.size)
Em::from_abs(extra_justification, glyph_size)
}
frame.size_mut().x += justification_left.at(self.size)
+ justification_right.at(self.size);
frame.size_mut().x += justification_left.at(glyph_size)
+ justification_right.at(glyph_size);
// We may not be able to reach the offset completely if
// it exceeds u16, but better to have a roughly correct
@ -304,7 +308,7 @@ impl<'a> ShapedText<'a> {
let item = TextItem {
font,
size: self.size,
size: glyph_size,
lang: self.lang,
region: self.region,
fill: fill.clone(),
@ -336,12 +340,13 @@ impl<'a> ShapedText<'a> {
let mut top = Abs::zero();
let mut bottom = Abs::zero();
let size = TextElem::size_in(self.styles);
let top_edge = TextElem::top_edge_in(self.styles);
let bottom_edge = TextElem::bottom_edge_in(self.styles);
// Expand top and bottom by reading the font's vertical metrics.
let mut expand = |font: &Font, bounds: TextEdgeBounds| {
let (t, b) = font.edges(top_edge, bottom_edge, self.size, bounds);
let (t, b) = font.edges(top_edge, bottom_edge, size, bounds);
top.set_max(t);
bottom.set_max(b);
};
@ -388,18 +393,16 @@ impl<'a> ShapedText<'a> {
pub fn stretchability(&self) -> Abs {
self.glyphs
.iter()
.map(|g| g.stretchability().0 + g.stretchability().1)
.sum::<Em>()
.at(self.size)
.map(|g| (g.stretchability().0 + g.stretchability().1).at(g.size))
.sum()
}
/// The shrinkability of the text
pub fn shrinkability(&self) -> Abs {
self.glyphs
.iter()
.map(|g| g.shrinkability().0 + g.shrinkability().1)
.sum::<Em>()
.at(self.size)
.map(|g| (g.shrinkability().0 + g.shrinkability().1).at(g.size))
.sum()
}
/// Reshape a range of the shaped text, reusing information from this
@ -418,9 +421,8 @@ impl<'a> ShapedText<'a> {
lang: self.lang,
region: self.region,
styles: self.styles,
size: self.size,
variant: self.variant,
width: glyphs.iter().map(|g| g.x_advance).sum::<Em>().at(self.size),
width: glyphs_width(glyphs),
glyphs: Cow::Borrowed(glyphs),
}
} else {
@ -484,13 +486,15 @@ impl<'a> ShapedText<'a> {
// that subtracting either of the endpoints by self.base doesn't
// underflow. See <https://github.com/typst/typst/issues/2283>.
.unwrap_or_else(|| self.base..self.base);
self.width += x_advance.at(self.size);
let size = TextElem::size_in(self.styles);
self.width += x_advance.at(size);
let glyph = ShapedGlyph {
font,
glyph_id: glyph_id.0,
x_advance,
x_offset: Em::zero(),
y_offset: Em::zero(),
size,
adjustability: Adjustability::default(),
range,
safe_to_break: true,
@ -666,6 +670,7 @@ fn shape<'a>(
region: Option<Region>,
) -> ShapedText<'a> {
let size = TextElem::size_in(styles);
let shift_settings = TextElem::shift_settings_in(styles);
let mut ctx = ShapingContext {
engine,
size,
@ -676,6 +681,7 @@ fn shape<'a>(
features: features(styles),
fallback: TextElem::fallback_in(styles),
dir,
shift_settings,
};
if !text.is_empty() {
@ -698,12 +704,17 @@ fn shape<'a>(
region,
styles,
variant: ctx.variant,
size,
width: ctx.glyphs.iter().map(|g| g.x_advance).sum::<Em>().at(size),
width: glyphs_width(&ctx.glyphs),
glyphs: Cow::Owned(ctx.glyphs),
}
}
/// Computes the width of a run of glyphs relative to the font size, accounting
/// for their individual scaling factors and other font metrics.
fn glyphs_width(glyphs: &[ShapedGlyph]) -> Abs {
glyphs.iter().map(|g| g.x_advance.at(g.size)).sum()
}
/// Holds shaping results and metadata common to all shaped segments.
struct ShapingContext<'a, 'v> {
engine: &'a Engine<'v>,
@ -715,6 +726,7 @@ struct ShapingContext<'a, 'v> {
features: Vec<rustybuzz::Feature>,
fallback: bool,
dir: Dir,
shift_settings: Option<ShiftSettings>,
}
/// Shape text with font fallback using the `families` iterator.
@ -789,6 +801,18 @@ fn shape_segment<'a>(
// text extraction.
buffer.set_flags(BufferFlags::REMOVE_DEFAULT_IGNORABLES);
let (script_shift, script_compensation, scale, shift_feature) = ctx
.shift_settings
.map_or((Em::zero(), Em::zero(), Em::one(), None), |settings| {
determine_shift(text, &font, settings)
});
let has_shift_feature = shift_feature.is_some();
if let Some(feat) = shift_feature {
// Temporarily push the feature.
ctx.features.push(feat)
}
// Prepare the shape plan. This plan depends on direction, script, language,
// and features, but is independent from the text and can thus be memoized.
let plan = create_shape_plan(
@ -799,6 +823,10 @@ fn shape_segment<'a>(
&ctx.features,
);
if has_shift_feature {
ctx.features.pop();
}
// Shape!
let buffer = rustybuzz::shape_with_plan(font.rusty(), &plan, buffer);
let infos = buffer.glyph_infos();
@ -869,8 +897,9 @@ fn shape_segment<'a>(
glyph_id: info.glyph_id as u16,
// TODO: Don't ignore y_advance.
x_advance,
x_offset: font.to_em(pos[i].x_offset),
y_offset: font.to_em(pos[i].y_offset),
x_offset: font.to_em(pos[i].x_offset) + script_compensation,
y_offset: font.to_em(pos[i].y_offset) + script_shift,
size: scale.at(ctx.size),
adjustability: Adjustability::default(),
range: start..end,
safe_to_break: !info.unsafe_to_break(),
@ -932,6 +961,64 @@ fn shape_segment<'a>(
ctx.used.pop();
}
/// Returns a `(script_shift, script_compensation, scale, feature)` quadruplet
/// describing how to produce scripts.
///
/// Those values determine how the rendered text should be transformed to
/// display sub-/super-scripts. If the OpenType feature can be used, the
/// rendered text should not be transformed in any way, and so those values are
/// neutral (`(0, 0, 1, None)`). If scripts should be synthesized, those values
/// determine how to transform the rendered text to display scripts as expected.
fn determine_shift(
text: &str,
font: &Font,
settings: ShiftSettings,
) -> (Em, Em, Em, Option<Feature>) {
settings
.typographic
.then(|| {
// If typographic scripts are enabled (i.e., we want to use the
// OpenType feature instead of synthesizing if possible), we add
// "subs"/"sups" to the feature list if supported by the font.
// In case of a problem, we just early exit
let gsub = font.rusty().tables().gsub?;
let subtable_index =
gsub.features.find(settings.kind.feature())?.lookup_indices.get(0)?;
let coverage = gsub
.lookups
.get(subtable_index)?
.subtables
.get::<SubstitutionSubtable>(0)?
.coverage();
text.chars()
.all(|c| {
font.rusty().glyph_index(c).is_some_and(|i| coverage.contains(i))
})
.then(|| {
// If we can use the OpenType feature, we can keep the text
// as is.
(
Em::zero(),
Em::zero(),
Em::one(),
Some(Feature::new(settings.kind.feature(), 1, ..)),
)
})
})
// Reunite the cases where `typographic` is `false` or where using the
// OpenType feature would not work.
.flatten()
.unwrap_or_else(|| {
let script_metrics = settings.kind.read_metrics(font.metrics());
(
settings.shift.unwrap_or(script_metrics.vertical_offset),
script_metrics.horizontal_offset,
settings.size.unwrap_or(script_metrics.height),
None,
)
})
}
/// Create a shape plan.
#[comemo::memoize]
pub fn create_shape_plan(
@ -963,6 +1050,7 @@ fn shape_tofus(ctx: &mut ShapingContext, base: usize, text: &str, font: Font) {
x_advance,
x_offset: Em::zero(),
y_offset: Em::zero(),
size: ctx.size,
adjustability: Adjustability::default(),
range: start..end,
safe_to_break: true,
@ -985,9 +1073,8 @@ fn shape_tofus(ctx: &mut ShapingContext, base: usize, text: &str, font: Font) {
/// Apply tracking and spacing to the shaped glyphs.
fn track_and_space(ctx: &mut ShapingContext) {
let tracking = Em::from_length(TextElem::tracking_in(ctx.styles), ctx.size);
let spacing =
TextElem::spacing_in(ctx.styles).map(|abs| Em::from_length(abs, ctx.size));
let tracking = Em::from_abs(TextElem::tracking_in(ctx.styles), ctx.size);
let spacing = TextElem::spacing_in(ctx.styles).map(|abs| Em::from_abs(abs, ctx.size));
let mut glyphs = ctx.glyphs.iter_mut().peekable();
while let Some(glyph) = glyphs.next() {

6
crates/typst-layout/src/math/fragment.rs
View File

@ -215,7 +215,7 @@ impl MathFragment {
&glyph.item.font,
GlyphId(glyph.item.glyphs[glyph_index].id),
corner,
Em::from_length(height, glyph.item.size),
Em::from_abs(height, glyph.item.size),
)
.unwrap_or_default()
.at(glyph.item.size)
@ -767,8 +767,8 @@ fn assemble(
advance += ratio * (max_overlap - min_overlap);
}
let (x, y) = match axis {
Axis::X => (Em::from_length(advance, base.item.size), Em::zero()),
Axis::Y => (Em::zero(), Em::from_length(advance, base.item.size)),
Axis::X => (Em::from_abs(advance, base.item.size), Em::zero()),
Axis::Y => (Em::zero(), Em::from_abs(advance, base.item.size)),
};
glyphs.push(Glyph {
id: part.glyph_id.0,

2
crates/typst-library/src/foundations/array.rs
View File

@ -604,7 +604,7 @@ impl Array {
Ok(acc)
}
/// Calculates the product all items (works for all types that can be
/// Calculates the product of all items (works for all types that can be
/// multiplied).
#[func]
pub fn product(

8
crates/typst-library/src/foundations/calc.rs
View File

@ -207,9 +207,9 @@ pub fn sqrt(
/// ```
#[func]
pub fn root(
/// The expression to take the root of
/// The expression to take the root of.
radicand: f64,
/// Which root of the radicand to take
/// Which root of the radicand to take.
index: Spanned<i64>,
) -> SourceResult<f64> {
if index.v == 0 {
@ -317,7 +317,7 @@ pub fn asin(
/// ```
#[func(title = "Arccosine")]
pub fn acos(
/// The number whose arcsine to calculate. Must be between -1 and 1.
/// The number whose arccosine to calculate. Must be between -1 and 1.
value: Spanned<Num>,
) -> SourceResult<Angle> {
let val = value.v.float();
@ -387,7 +387,7 @@ pub fn cosh(
value.cosh()
}
/// Calculates the hyperbolic tangent of an hyperbolic angle.
/// Calculates the hyperbolic tangent of a hyperbolic angle.
///
/// ```example
/// #calc.tanh(0) \

17
crates/typst-library/src/layout/em.rs
View File

@ -6,7 +6,7 @@ use ecow::EcoString;
use typst_utils::{Numeric, Scalar};
use crate::foundations::{cast, repr, Repr, Resolve, StyleChain, Value};
use crate::layout::Abs;
use crate::layout::{Abs, Length};
use crate::text::TextElem;
/// A length that is relative to the font size.
@ -26,18 +26,18 @@ impl Em {
Self(Scalar::ONE)
}
/// Create a font-relative length.
/// Creates a font-relative length.
pub const fn new(em: f64) -> Self {
Self(Scalar::new(em))
}
/// Create an em length from font units at the given units per em.
/// Creates an em length from font units at the given units per em.
pub fn from_units(units: impl Into<f64>, units_per_em: f64) -> Self {
Self(Scalar::new(units.into() / units_per_em))
}
/// Create an em length from a length at the given font size.
pub fn from_length(length: Abs, font_size: Abs) -> Self {
/// Creates an em length from an absolute length at the given font size.
pub fn from_abs(length: Abs, font_size: Abs) -> Self {
let result = length / font_size;
if result.is_finite() {
Self(Scalar::new(result))
@ -46,6 +46,11 @@ impl Em {
}
}
/// Creates an em length from a length at the given font size.
pub fn from_length(length: Length, font_size: Abs) -> Em {
length.em + Self::from_abs(length.abs, font_size)
}
/// The number of em units.
pub const fn get(self) -> f64 {
(self.0).get()
@ -56,7 +61,7 @@ impl Em {
Self::new(self.get().abs())
}
/// Convert to an absolute length at the given font size.
/// Converts to an absolute length at the given font size.
pub fn at(self, font_size: Abs) -> Abs {
let resolved = font_size * self.get();
if resolved.is_finite() {

39
crates/typst-library/src/text/font/mod.rs
View File

@ -228,6 +228,10 @@ pub struct FontMetrics {
pub underline: LineMetrics,
/// Recommended metrics for an overline.
pub overline: LineMetrics,
/// Metrics for subscripts, if provided by the font.
pub subscript: Option<ScriptMetrics>,
/// Metrics for superscripts, if provided by the font.
pub superscript: Option<ScriptMetrics>,
}
impl FontMetrics {
@ -240,6 +244,7 @@ impl FontMetrics {
let cap_height = ttf.capital_height().filter(|&h| h > 0).map_or(ascender, to_em);
let x_height = ttf.x_height().filter(|&h| h > 0).map_or(ascender, to_em);
let descender = to_em(ttf.typographic_descender().unwrap_or(ttf.descender()));
let strikeout = ttf.strikeout_metrics();
let underline = ttf.underline_metrics();
@ -262,6 +267,20 @@ impl FontMetrics {
thickness: underline.thickness,
};
let subscript = ttf.subscript_metrics().map(|metrics| ScriptMetrics {
width: to_em(metrics.x_size),
height: to_em(metrics.y_size),
horizontal_offset: to_em(metrics.x_offset),
vertical_offset: -to_em(metrics.y_offset),
});
let superscript = ttf.superscript_metrics().map(|metrics| ScriptMetrics {
width: to_em(metrics.x_size),
height: to_em(metrics.y_size),
horizontal_offset: to_em(metrics.x_offset),
vertical_offset: to_em(metrics.y_offset),
});
Self {
units_per_em,
ascender,
@ -271,6 +290,8 @@ impl FontMetrics {
strikethrough,
underline,
overline,
superscript,
subscript,
}
}
@ -296,6 +317,24 @@ pub struct LineMetrics {
pub thickness: Em,
}
/// Metrics for subscripts or superscripts.
#[derive(Debug, Copy, Clone)]
pub struct ScriptMetrics {
/// The width of those scripts, relative to the outer font size.
pub width: Em,
/// The height of those scripts, relative to the outer font size.
pub height: Em,
/// The horizontal (to the right) offset of those scripts, relative to the
/// outer font size.
///
/// This is used for italic correction.
pub horizontal_offset: Em,
/// The vertical (to the top) offset of those scripts, relative to the outer font size.
///
/// For superscripts, this is positive. For subscripts, this is negative.
pub vertical_offset: Em,
}
/// Identifies a vertical metric of a font.
#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash, Cast)]
pub enum VerticalFontMetric {

6
crates/typst-library/src/text/mod.rs
View File

@ -755,6 +755,12 @@ pub struct TextElem {
#[internal]
#[ghost]
pub smallcaps: Option<Smallcaps>,
/// The configuration for superscripts or subscripts, if one of them is
/// enabled.
#[internal]
#[ghost]
pub shift_settings: Option<ShiftSettings>,
}
impl TextElem {

314
crates/typst-library/src/text/shift.rs
View File

@ -1,14 +1,13 @@
use ecow::EcoString;
use crate::diag::SourceResult;
use crate::engine::Engine;
use crate::foundations::{
elem, Content, NativeElement, Packed, SequenceElem, Show, StyleChain, TargetElem,
elem, Content, NativeElement, Packed, Show, Smart, StyleChain, TargetElem,
};
use crate::html::{tag, HtmlElem};
use crate::layout::{Em, Length};
use crate::text::{variant, SpaceElem, TextElem, TextSize};
use crate::World;
use crate::text::{FontMetrics, TextElem, TextSize};
use ttf_parser::Tag;
use typst_library::text::ScriptMetrics;
/// Renders text in subscript.
///
@ -20,11 +19,16 @@ use crate::World;
/// ```
#[elem(title = "Subscript", Show)]
pub struct SubElem {
/// Whether to prefer the dedicated subscript characters of the font.
/// Whether to create artificial subscripts by lowering and scaling down
/// regular glyphs.
///
/// If this is enabled, Typst first tries to transform the text to subscript
/// codepoints. If that fails, it falls back to rendering lowered and shrunk
/// normal letters.
/// Ideally, subscripts glyphs are provided by the font (using the `subs`
/// OpenType feature). Otherwise, Typst is able to synthesize subscripts.
///
/// When this is set to `{false}`, synthesized glyphs will be used
/// regardless of whether the font provides dedicated subscript glyphs. When
/// `{true}`, synthesized glyphs may still be used in case the font does not
/// provide the necessary subscript glyphs.
///
/// ```example
/// N#sub(typographic: true)[1]
@ -33,17 +37,27 @@ pub struct SubElem {
#[default(true)]
pub typographic: bool,
/// The baseline shift for synthetic subscripts. Does not apply if
/// `typographic` is true and the font has subscript codepoints for the
/// given `body`.
#[default(Em::new(0.2).into())]
pub baseline: Length,
/// The downward baseline shift for synthesized subscripts.
///
/// This only applies to synthesized subscripts. In other words, this has no
/// effect if `typographic` is `{true}` and the font provides the necessary
/// subscript glyphs.
///
/// If set to `{auto}`, the baseline is shifted according to the metrics
/// provided by the font, with a fallback to `{0.2em}` in case the font does
/// not define the necessary metrics.
pub baseline: Smart<Length>,
/// The font size for synthetic subscripts. Does not apply if
/// `typographic` is true and the font has subscript codepoints for the
/// given `body`.
#[default(TextSize(Em::new(0.6).into()))]
pub size: TextSize,
/// The font size for synthesized subscripts.
///
/// This only applies to synthesized subscripts. In other words, this has no
/// effect if `typographic` is `{true}` and the font provides the necessary
/// subscript glyphs.
///
/// If set to `{auto}`, the size is scaled according to the metrics provided
/// by the font, with a fallback to `{0.6em}` in case the font does not
/// define the necessary metrics.
pub size: Smart<TextSize>,
/// The text to display in subscript.
#[required]
@ -52,7 +66,7 @@ pub struct SubElem {
impl Show for Packed<SubElem> {
#[typst_macros::time(name = "sub", span = self.span())]
fn show(&self, engine: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
fn show(&self, _: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
let body = self.body.clone();
if TargetElem::target_in(styles).is_html() {
@ -62,17 +76,14 @@ impl Show for Packed<SubElem> {
.spanned(self.span()));
}
if self.typographic(styles) {
if let Some(text) = convert_script(&body, true) {
if is_shapable(engine, &text, styles) {
return Ok(TextElem::packed(text));
}
}
};
Ok(body
.styled(TextElem::set_baseline(self.baseline(styles)))
.styled(TextElem::set_size(self.size(styles))))
show_script(
styles,
body,
self.typographic(styles),
self.baseline(styles),
self.size(styles),
ScriptKind::Sub,
)
}
}
@ -86,11 +97,16 @@ impl Show for Packed<SubElem> {
/// ```
#[elem(title = "Superscript", Show)]
pub struct SuperElem {
/// Whether to prefer the dedicated superscript characters of the font.
/// Whether to create artificial superscripts by raising and scaling down
/// regular glyphs.
///
/// If this is enabled, Typst first tries to transform the text to
/// superscript codepoints. If that fails, it falls back to rendering
/// raised and shrunk normal letters.
/// Ideally, superscripts glyphs are provided by the font (using the `sups`
/// OpenType feature). Otherwise, Typst is able to synthesize superscripts.
///
/// When this is set to `{false}`, synthesized glyphs will be used
/// regardless of whether the font provides dedicated superscript glyphs.
/// When `{true}`, synthesized glyphs may still be used in case the font
/// does not provide the necessary superscript glyphs.
///
/// ```example
/// N#super(typographic: true)[1]
@ -99,17 +115,31 @@ pub struct SuperElem {
#[default(true)]
pub typographic: bool,
/// The baseline shift for synthetic superscripts. Does not apply if
/// `typographic` is true and the font has superscript codepoints for the
/// given `body`.
#[default(Em::new(-0.5).into())]
pub baseline: Length,
/// The downward baseline shift for synthesized superscripts.
///
/// This only applies to synthesized superscripts. In other words, this has
/// no effect if `typographic` is `{true}` and the font provides the
/// necessary superscript glyphs.
///
/// If set to `{auto}`, the baseline is shifted according to the metrics
/// provided by the font, with a fallback to `{-0.5em}` in case the font
/// does not define the necessary metrics.
///
/// Note that, since the baseline shift is applied downward, you will need
/// to provide a negative value for the content to appear as raised above
/// the normal baseline.
pub baseline: Smart<Length>,
/// The font size for synthetic superscripts. Does not apply if
/// `typographic` is true and the font has superscript codepoints for the
/// given `body`.
#[default(TextSize(Em::new(0.6).into()))]
pub size: TextSize,
/// The font size for synthesized superscripts.
///
/// This only applies to synthesized superscripts. In other words, this has
/// no effect if `typographic` is `{true}` and the font provides the
/// necessary superscript glyphs.
///
/// If set to `{auto}`, the size is scaled according to the metrics provided
/// by the font, with a fallback to `{0.6em}` in case the font does not
/// define the necessary metrics.
pub size: Smart<TextSize>,
/// The text to display in superscript.
#[required]
@ -118,7 +148,7 @@ pub struct SuperElem {
impl Show for Packed<SuperElem> {
#[typst_macros::time(name = "super", span = self.span())]
fn show(&self, engine: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
fn show(&self, _: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
let body = self.body.clone();
if TargetElem::target_in(styles).is_html() {
@ -128,104 +158,102 @@ impl Show for Packed<SuperElem> {
.spanned(self.span()));
}
if self.typographic(styles) {
if let Some(text) = convert_script(&body, false) {
if is_shapable(engine, &text, styles) {
return Ok(TextElem::packed(text));
show_script(
styles,
body,
self.typographic(styles),
self.baseline(styles),
self.size(styles),
ScriptKind::Super,
)
}
}
fn show_script(
styles: StyleChain,
body: Content,
typographic: bool,
baseline: Smart<Length>,
size: Smart<TextSize>,
kind: ScriptKind,
) -> SourceResult<Content> {
let font_size = TextElem::size_in(styles);
Ok(body.styled(TextElem::set_shift_settings(Some(ShiftSettings {
typographic,
shift: baseline.map(|l| -Em::from_length(l, font_size)),
size: size.map(|t| Em::from_length(t.0, font_size)),
kind,
}))))
}
/// Configuration values for sub- or superscript text.
#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
pub struct ShiftSettings {
/// Whether the OpenType feature should be used if possible.
pub typographic: bool,
/// The baseline shift of the script, relative to the outer text size.
///
/// For superscripts, this is positive. For subscripts, this is negative. A
/// value of [`Smart::Auto`] indicates that the value should be obtained
/// from font metrics.
pub shift: Smart<Em>,
/// The size of the script, relative to the outer text size.
///
/// A value of [`Smart::Auto`] indicates that the value should be obtained
/// from font metrics.
pub size: Smart<Em>,
/// The kind of script (either a subscript, or a superscript).
///
/// This is used to know which OpenType table to use to resolve
/// [`Smart::Auto`] values.
pub kind: ScriptKind,
}
#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
pub enum ScriptKind {
Sub,
Super,
}
impl ScriptKind {
/// Returns the default metrics for this script kind.
///
/// This can be used as a last resort if neither the user nor the font
/// provided those metrics.
pub fn default_metrics(self) -> &'static ScriptMetrics {
match self {
Self::Sub => &DEFAULT_SUBSCRIPT_METRICS,
Self::Super => &DEFAULT_SUPERSCRIPT_METRICS,
}
}
/// Reads the script metrics from the font table for to this script kind.
pub fn read_metrics(self, font_metrics: &FontMetrics) -> &ScriptMetrics {
match self {
Self::Sub => font_metrics.subscript.as_ref(),
Self::Super => font_metrics.superscript.as_ref(),
}
.unwrap_or(self.default_metrics())
}
/// The corresponding OpenType feature.
pub const fn feature(self) -> Tag {
match self {
Self::Sub => Tag::from_bytes(b"subs"),
Self::Super => Tag::from_bytes(b"sups"),
}
}
}
static DEFAULT_SUBSCRIPT_METRICS: ScriptMetrics = ScriptMetrics {
width: Em::new(0.6),
height: Em::new(0.6),
horizontal_offset: Em::zero(),
vertical_offset: Em::new(-0.2),
};
Ok(body
.styled(TextElem::set_baseline(self.baseline(styles)))
.styled(TextElem::set_size(self.size(styles))))
}
}
/// Find and transform the text contained in `content` to the given script kind
/// if and only if it only consists of `Text`, `Space`, and `Empty` leaves.
fn convert_script(content: &Content, sub: bool) -> Option<EcoString> {
if content.is::<SpaceElem>() {
Some(' '.into())
} else if let Some(elem) = content.to_packed::<TextElem>() {
if sub {
elem.text.chars().map(to_subscript_codepoint).collect()
} else {
elem.text.chars().map(to_superscript_codepoint).collect()
}
} else if let Some(sequence) = content.to_packed::<SequenceElem>() {
sequence
.children
.iter()
.map(|item| convert_script(item, sub))
.collect()
} else {
None
}
}
/// Checks whether the first retrievable family contains all code points of the
/// given string.
fn is_shapable(engine: &Engine, text: &str, styles: StyleChain) -> bool {
let world = engine.world;
for family in TextElem::font_in(styles) {
if let Some(font) = world
.book()
.select(family.as_str(), variant(styles))
.and_then(|id| world.font(id))
{
let covers = family.covers();
return text.chars().all(|c| {
covers.is_none_or(|cov| cov.is_match(c.encode_utf8(&mut [0; 4])))
&& font.ttf().glyph_index(c).is_some()
});
}
}
false
}
/// Convert a character to its corresponding Unicode superscript.
fn to_superscript_codepoint(c: char) -> Option<char> {
match c {
'1' => Some('¹'),
'2' => Some('²'),
'3' => Some('³'),
'0' | '4'..='9' => char::from_u32(c as u32 - '0' as u32 + '⁰' as u32),
'+' => Some('⁺'),
'−' => Some('⁻'),
'=' => Some('⁼'),
'(' => Some('⁽'),
')' => Some('⁾'),
'n' => Some('ⁿ'),
'i' => Some('ⁱ'),
' ' => Some(' '),
_ => None,
}
}
/// Convert a character to its corresponding Unicode subscript.
fn to_subscript_codepoint(c: char) -> Option<char> {
match c {
'0'..='9' => char::from_u32(c as u32 - '0' as u32 + '₀' as u32),
'+' => Some('₊'),
'−' => Some('₋'),
'=' => Some('₌'),
'(' => Some('₍'),
')' => Some('₎'),
'a' => Some('ₐ'),
'e' => Some('ₑ'),
'o' => Some('ₒ'),
'x' => Some('ₓ'),
'h' => Some('ₕ'),
'k' => Some('ₖ'),
'l' => Some('ₗ'),
'm' => Some('ₘ'),
'n' => Some('ₙ'),
'p' => Some('ₚ'),
's' => Some('ₛ'),
't' => Some('ₜ'),
' ' => Some(' '),
_ => None,
}
}
static DEFAULT_SUPERSCRIPT_METRICS: ScriptMetrics = ScriptMetrics {
width: Em::new(0.6),
height: Em::new(0.6),
horizontal_offset: Em::zero(),
vertical_offset: Em::new(0.5),
};

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

@ -172,7 +172,7 @@ pub enum PdfStandard {
/// PDF/A-2u.
#[serde(rename = "a-2u")]
A_2u,
/// PDF/A-3u.
/// PDF/A-3b.
#[serde(rename = "a-3b")]
A_3b,
/// PDF/A-3u.

4
crates/typst-utils/src/lib.rs
View File

@ -395,6 +395,10 @@ pub fn default_math_class(c: char) -> Option<MathClass> {
// https://github.com/typst/typst/issues/5764
'⟇' => Some(MathClass::Binary),
// Arabic comma.
// https://github.com/latex3/unicode-math/pull/633#issuecomment-2028936135
'،' => Some(MathClass::Punctuation),
c => unicode_math_class::class(c),
}
}

2
docs/tutorial/3-advanced.md
View File

@ -79,7 +79,7 @@ the right.
Last but not least is the `numbering` argument. Here, we can provide a
[numbering pattern]($numbering) that defines how to number the pages. By
setting into to `{"1"}`, Typst only displays the bare page number. Setting it to
setting it to `{"1"}`, Typst only displays the bare page number. Setting it to
`{"(1/1)"}` would have displayed the current page and total number of pages
surrounded by parentheses. And we could even have provided a completely custom
function here to format things to our liking.

BIN
tests/ref/issue-4454-footnote-ref-numbering.png
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 841 B

After

Width:  |  Height:  |  Size: 903 B

BIN
tests/ref/long-scripts.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 956 B

BIN
tests/ref/script-metrics-bundeled-fonts.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 3.0 KiB

BIN
tests/ref/sub-super-italic-compensation.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 1.3 KiB

BIN
tests/ref/sub-super-non-typographic.png
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 311 B

After

Width:  |  Height:  |  Size: 318 B

BIN
tests/ref/sub-super-typographic.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 1.3 KiB

BIN
tests/ref/sub-super.png
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 1.1 KiB

After

Width:  |  Height:  |  Size: 1.2 KiB

BIN
tests/ref/super-highlight.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 1.3 KiB

BIN
tests/ref/super-underline.png
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 1.8 KiB

After

Width:  |  Height:  |  Size: 835 B

79
tests/suite/text/shift.typ
View File

@ -1,22 +1,89 @@
// Test sub- and superscript shifts.
--- sub-super ---
#let sq = box(square(size: 4pt))
#table(
columns: 3,
[Typo.], [Fallb.], [Synth],
[x#super[1]], [x#super[5n]], [x#super[2 #box(square(size: 6pt))]],
[x#sub[1]], [x#sub[5n]], [x#sub[2 #box(square(size: 6pt))]],
[Typo.], [Fallb.], [Synth.],
[x#super[1#sq]], [x#super[5: #sq]], [x#super(typographic: false)[2 #sq]],
[x#sub[1#sq]], [x#sub[5: #sq]], [x#sub(typographic: false)[2 #sq]],
)
--- sub-super-typographic ---
#set text(size: 20pt)
// Libertinus Serif supports "subs" and "sups" for `typo` and `sq`, but not for
// `synth`.
#let synth = [1,2,3]
#let typo = [123]
#let sq = [1#box(square(size: 4pt))2]
x#super(synth) x#super(typo) x#super(sq) \
x#sub(synth) x#sub(typo) x#sub(sq)
--- sub-super-italic-compensation ---
#set text(size: 20pt, style: "italic")
// Libertinus Serif supports "subs" and "sups" for `typo`, but not for `synth`.
#let synth = [1,2,3]
#let typo = [123]
#let sq = [1#box(square(size: 4pt))2]
x#super(synth) x#super(typo) x#super(sq) \
x#sub(synth) x#sub(typo) x#sub(sq)
--- sub-super-non-typographic ---
#set super(typographic: false, baseline: -0.25em, size: 0.7em)
n#super[1], n#sub[2], ... n#super[N]
--- super-underline ---
#set underline(stroke: 0.5pt, offset: 0.15em)
#underline[The claim#super[\[4\]]] has been disputed. \
The claim#super[#underline[\[4\]]] has been disputed. \
It really has been#super(box(text(baseline: 0pt, underline[\[4\]]))) \
#set super(typographic: false)
#underline[A#super[4]] B \
A#super[#underline[4]] B \
A #underline(super[4]) B \
#set super(typographic: true)
#underline[A#super[4]] B \
A#super[#underline[4]] B \
A #underline(super[4]) B
--- super-highlight ---
#set super(typographic: false)
#highlight[A#super[4]] B \
A#super[#highlight[4]] B \
A#super(highlight[4]) \
#set super(typographic: true)
#highlight[A#super[4]] B \
A#super[#highlight[4]] B \
A#super(highlight[4])
--- super-1em ---
#set text(size: 10pt)
#super(context test(1em.to-absolute(), 10pt))
--- long-scripts ---
|longscript| \
|#super(typographic: true)[longscript]| \
|#super(typographic: false)[longscript]| \
|#sub(typographic: true)[longscript]| \
|#sub(typographic: false)[longscript]|
--- script-metrics-bundeled-fonts ---
// Tests whether the script metrics are used properly by synthesizing
// superscripts and subscripts for all bundled fonts.
#set super(typographic: false)
#set sub(typographic: false)
#let test(font, weights, styles) = {
for weight in weights {
for style in styles {
text(font: font, weight: weight, style: style)[Xx#super[Xx]#sub[Xx]]
linebreak()
}
}
}
#test("DejaVu Sans Mono", ("regular", "bold"), ("normal", "oblique"))
#test("Libertinus Serif", ("regular", "semibold", "bold"), ("normal", "italic"))
#test("New Computer Modern", ("regular", "bold"), ("normal", "italic"))
#test("New Computer Modern Math", (400, 450, "bold"), ("normal",))
--- basic-sup-sub html ---
1#super[st], 2#super[nd], 3#super[rd].

9
tools/test-helper/package.json
View File

@ -94,9 +94,12 @@
"watch": "tsc -watch -p ./"
},
"devDependencies": {
"@types/node": "18.x",
"@types/vscode": "^1.88.0",
"typescript": "^5.3.3"
"@types/node": "^24.0.4",
"@types/vscode": "^1.101.0",
"typescript": "^5.8.3"
},
"dependencies": {
"shiki": "^3.7.0"
},
"engines": {
"vscode": "^1.88.0"

285
tools/test-helper/src/extension.ts
View File

@ -1,6 +1,7 @@
import * as vscode from "vscode";
import * as cp from "child_process";
import { clearInterval } from "timers";
const shiki = import("shiki"); // Normal import causes TypeScript problems.
// Called when an activation event is triggered. Our activation event is the
// presence of "tests/suite/playground.typ".
@ -17,6 +18,8 @@ class TestHelper {
opened?: {
// The tests's name.
name: string;
// The test's attributes.
attrs: string[];
// The WebView panel that displays the test images and output.
panel: vscode.WebviewPanel;
};
@ -44,18 +47,18 @@ class TestHelper {
);
// Triggered when clicking "View" in the lens.
this.registerCommand("typst-test-helper.viewFromLens", (name) =>
this.viewFromLens(name)
this.registerCommand("typst-test-helper.viewFromLens", (name, attrs) =>
this.viewFromLens(name, attrs)
);
// Triggered when clicking "Run" in the lens.
this.registerCommand("typst-test-helper.runFromLens", (name) =>
this.runFromLens(name)
this.registerCommand("typst-test-helper.runFromLens", (name, attrs) =>
this.runFromLens(name, attrs)
);
// Triggered when clicking "Save" in the lens.
this.registerCommand("typst-test-helper.saveFromLens", (name) =>
this.saveFromLens(name)
this.registerCommand("typst-test-helper.saveFromLens", (name, attrs) =>
this.saveFromLens(name, attrs)
);
// Triggered when clicking "Terminal" in the lens.
@ -121,31 +124,32 @@ class TestHelper {
const lenses = [];
for (let nr = 0; nr < document.lineCount; nr++) {
const line = document.lineAt(nr);
const re = /^--- ([\d\w-]+)( [\d\w-]+)* ---$/;
const re = /^--- ([\d\w-]+)(( [\d\w-]+)*) ---$/;
const m = line.text.match(re);
if (!m) {
continue;
}
const name = m[1];
const attrs = m[2].trim().split(" ");
lenses.push(
new vscode.CodeLens(line.range, {
title: "View",
tooltip: "View the test output and reference in a new tab",
command: "typst-test-helper.viewFromLens",
arguments: [name],
arguments: [name, attrs],
}),
new vscode.CodeLens(line.range, {
title: "Run",
tooltip: "Run the test and view the results in a new tab",
command: "typst-test-helper.runFromLens",
arguments: [name],
arguments: [name, attrs],
}),
new vscode.CodeLens(line.range, {
title: "Save",
tooltip: "Run and view the test and save the reference output",
command: "typst-test-helper.saveFromLens",
arguments: [name],
arguments: [name, attrs],
}),
new vscode.CodeLens(line.range, {
title: "Terminal",
@ -159,40 +163,49 @@ class TestHelper {
}
// Triggered when clicking "View" in the lens.
private viewFromLens(name: string) {
if (this.opened?.name == name) {
private viewFromLens(name: string, attrs: string[]) {
if (
this.opened?.name == name &&
this.opened.attrs.join(" ") == attrs.join(" ")
) {
this.opened.panel.reveal();
return;
}
if (this.opened) {
this.opened.name = name;
this.opened.attrs = attrs;
this.opened.panel.title = name;
} else {
const panel = vscode.window.createWebviewPanel(
"typst-test-helper.preview",
name,
vscode.ViewColumn.Beside,
{ enableFindWidget: true }
{ enableFindWidget: true, enableScripts: true }
);
panel.onDidDispose(() => (this.opened = undefined));
panel.webview.onDidReceiveMessage((message) => {
if (message.command === "openFile") {
vscode.env.openExternal(vscode.Uri.parse(message.uri));
}
});
this.opened = { name, panel };
this.opened = { name, attrs, panel };
}
this.refreshWebView();
}
// Triggered when clicking "Run" in the lens.
private runFromLens(name: string) {
this.viewFromLens(name);
private runFromLens(name: string, attrs: string[]) {
this.viewFromLens(name, attrs);
this.runFromPreview();
}
// Triggered when clicking "Run" in the lens.
private saveFromLens(name: string) {
this.viewFromLens(name);
private saveFromLens(name: string, attrs: string[]) {
this.viewFromLens(name, attrs);
this.saveFromPreview();
}
@ -288,41 +301,37 @@ class TestHelper {
private copyImageFilePathFromPreviewContext(webviewSection: string) {
if (!this.opened) return;
const { name } = this.opened;
const { png, ref } = getImageUris(name);
switch (webviewSection) {
case "png":
vscode.env.clipboard.writeText(png.fsPath);
break;
case "ref":
vscode.env.clipboard.writeText(ref.fsPath);
break;
default:
break;
}
const [bucket, format] = webviewSection.split("/");
vscode.env.clipboard.writeText(
getUri(name, bucket as Bucket, format as Format).fsPath
);
}
// Reloads the web view.
private refreshWebView(output?: { stdout: string; stderr: string }) {
if (!this.opened) return;
const { name, panel } = this.opened;
const { png, ref } = getImageUris(name);
const { name, attrs, panel } = this.opened;
if (panel) {
console.log(
`Refreshing WebView for ${name}` + (panel.visible ? " in background" : ""));
const webViewSrcs = {
png: panel.webview.asWebviewUri(png),
ref: panel.webview.asWebviewUri(ref),
};
`Refreshing WebView for ${name}` +
(panel.visible ? " in background" : "")
);
panel.webview.html = "";
// Make refresh notable.
setTimeout(() => {
setTimeout(async () => {
if (!panel) {
throw new Error("panel to refresh is falsy after waiting");
}
panel.webview.html = getWebviewContent(webViewSrcs, output);
panel.webview.html = await getWebviewContent(
panel,
name,
attrs,
output
);
}, 50);
}
}
@ -386,30 +395,43 @@ function getWorkspaceRoot() {
return vscode.workspace.workspaceFolders![0].uri;
}
// Returns the URIs for a test's images.
function getImageUris(name: string) {
const root = getWorkspaceRoot();
const png = vscode.Uri.joinPath(root, `tests/store/render/${name}.png`);
const ref = vscode.Uri.joinPath(root, `tests/ref/${name}.png`);
return { png, ref };
const EXTENSION = { html: "html", render: "png" };
type Bucket = "store" | "ref";
type Format = "html" | "render";
function getUri(name: string, bucket: Bucket, format: Format) {
let path;
if (bucket === "ref" && format === "render") {
path = `tests/ref/${name}.png`;
} else {
path = `tests/${bucket}/${format}/${name}.${EXTENSION[format]}`;
}
return vscode.Uri.joinPath(getWorkspaceRoot(), path);
}
// Produces the content of the WebView.
function getWebviewContent(
webViewSrcs: { png: vscode.Uri; ref: vscode.Uri },
async function getWebviewContent(
panel: vscode.WebviewPanel,
name: string,
attrs: string[],
output?: {
stdout: string;
stderr: string;
}
): string {
const escape = (text: string) =>
text.replace(/</g, "&lt;").replace(/>/g, "&gt;");
): Promise<string> {
const showHtml = attrs.includes("html");
const showRender = !showHtml || attrs.includes("render");
const stdoutHtml = output?.stdout
? `<h1>Standard output</h1><pre>${escape(output.stdout)}</pre>`
const stdout = output?.stdout
? `<h2>Standard output</h2><pre class="output">${escape(
output.stdout
)}</pre>`
: "";
const stderrHtml = output?.stderr
? `<h1>Standard error</h1><pre>${escape(output.stderr)}</pre>`
const stderr = output?.stderr
? `<h2>Standard error</h2><pre class="output">${escape(
output.stderr
)}</pre>`
: "";
return `
@ -449,46 +471,169 @@ function getWebviewContent(
color: #bebebe;
content: "Not present";
}
pre {
display: inline-block;
font-family: var(--vscode-editor-font-family);
text-align: left;
width: 80%;
h2 {
margin-bottom: 12px;
}
h2 a {
color: var(--vscode-editor-foreground);
text-decoration: underline;
}
h2 a:hover {
cursor: pointer;
}
.flex {
display: flex;
flex-wrap: wrap;
justify-content: center;
}
.vertical {
flex-direction: column;
}
.top-bottom {
display: flex;
flex-direction: column;
padding-inline: 32px;
width: calc(100vw - 64px);
}
pre {
font-family: var(--vscode-editor-font-family);
text-align: left;
white-space: pre-wrap;
}
pre.output {
display: inline-block;
width: 80%;
margin-block-start: 0;
}
pre.shiki {
background-color: transparent !important;
padding: 12px;
margin-block-start: 0;
}
pre.shiki code {
--vscode-textPreformat-background: transparent;
}
iframe, pre.shiki {
border: 1px solid rgb(189, 191, 204);
border-radius: 6px;
}
iframe {
background: white;
}
.vscode-dark iframe {
filter: invert(1) hue-rotate(180deg);
}
</style>
<script>
const api = acquireVsCodeApi()
function openFile(uri) {
api.postMessage({ command: 'openFile', uri });
}
function sizeIframe(obj){
obj.style.height = 0;
obj.style.height = obj.contentWindow.document.body.scrollHeight + 'px';
}
</script>
</head>
<body>
<div
${showRender ? renderSection(panel, name) : ""}
${showHtml ? await htmlSection(name) : ""}
${stdout}
${stderr}
</body>
</html>`;
}
function renderSection(panel: vscode.WebviewPanel, name: string) {
const outputUri = getUri(name, "store", "render");
const refUri = getUri(name, "ref", "render");
return `<div
class="flex"
data-vscode-context='{"preventDefaultContextMenuItems": true}'
>
<div>
<h1>Output</h1>
${linkedTitle("Output", outputUri)}
<img
class="output"
data-vscode-context='{"webviewSection":"png"}'
src="${webViewSrcs.png}"
data-vscode-context='{"bucket":"store", format: "render"}'
src="${panel.webview.asWebviewUri(outputUri)}"
alt="Placeholder"
>
</div>
<div>
<h1>Reference</h1>
${linkedTitle("Reference", refUri)}
<img
class="ref"
data-vscode-context='{"webviewSection":"ref"}'
src="${webViewSrcs.ref}"
data-vscode-context='{"bucket":"ref", format: "render"}'
src="${panel.webview.asWebviewUri(refUri)}"
alt="Placeholder"
>
</div>
</div>
${stdoutHtml}
${stderrHtml}
</body>
</html>`;
</div>`;
}
async function htmlSection(name: string) {
const storeHtml = await htmlSnippet(
"HTML Output",
getUri(name, "store", "html")
);
const refHtml = await htmlSnippet(
"HTML Reference",
getUri(name, "ref", "html")
);
return `<div
class="flex vertical"
data-vscode-context='{"preventDefaultContextMenuItems": true}'
>
${storeHtml}
${refHtml}
</div>`;
}
async function htmlSnippet(title: string, uri: vscode.Uri): Promise<string> {
try {
const data = await vscode.workspace.fs.readFile(uri);
const code = new TextDecoder("utf-8").decode(data);
return `<div>
${linkedTitle(title, uri)}
<div class="top-bottom">
${await highlight(code)}
<iframe srcdoc="${escape(code)}"></iframe>
</div>
</div>`;
} catch {
return `<div><h2>${title}</h2>Not present</div>`;
}
}
function linkedTitle(title: string, uri: vscode.Uri) {
return `<h2><a onclick="openFile('${uri.toString()}')">${title}</a></h2>`;
}
async function highlight(code: string): Promise<string> {
return (await shiki).codeToHtml(code, {
lang: "html",
theme: selectTheme(),
});
}
function selectTheme() {
switch (vscode.window.activeColorTheme.kind) {
case vscode.ColorThemeKind.Light:
case vscode.ColorThemeKind.HighContrastLight:
return "github-light";
case vscode.ColorThemeKind.Dark:
case vscode.ColorThemeKind.HighContrast:
return "github-dark";
}
}
function escape(text: string) {
return text
.replace(/&/g, "&amp;")
.replace(/</g, "&lt;")
.replace(/>/g, "&gt;")
.replace(/"/g, "&quot;")
.replace(/'/g, "&apos;");
}

5
tools/test-helper/tsconfig.json
View File

@ -1,9 +1,10 @@
{
"compilerOptions": {
"module": "Node16",
"module": "nodenext",
"lib": ["ES2022", "DOM"],
"target": "ES2022",
"moduleResolution": "nodenext",
"outDir": "dist",
"lib": ["ES2022"],
"sourceMap": true,
"rootDir": "src",
"strict": true