Skip to content
Source
Sign inSign up
Open History to see the last commit

slide-fonts.ts

211 lines7.5 KB

1// Adapted from opencode (MIT). Copyright (c) 2025 opencode. See LICENSE.opencode.
2import type {
3 PositionedTextRun,
4 PresentationHandle,
5 SlideDisplayList,
6 SlidePrimitive,
7} from "@betteroffice/pptx";
8import { resolveScriptFallbackFace } from "@betteroffice/fonts";
9import { loadFace, presentationFace } from "./fonts";
10import type { DeckText, FallbackScript, FontStyle } from "./slide-text";
11​
12/** A face the deck asks for: a family it names, or the fallback for a script the Latin faces lack. */
13type Want =
14 | { readonly family: string; readonly script?: undefined }
15 | { readonly script: FallbackScript; readonly family?: undefined };
16​
17/** A face registered with both the engine and the browser. */
18type Face = { readonly want: Want; readonly style: FontStyle; readonly css: string };
19​
20/**
21 * The faces one open deck draws with, added to `fonts`: the font set of the deck's own worker, which paints it. The
22 * engine shapes each face under the family name the deck uses, and the browser holds the same bytes under a private
23 * name that the laid-out frames are renamed to. Painting then matches shaping, and the deck's names (such as Inter or
24 * Segoe UI) never replace a font the painter itself needs.
25 */
26export function slideFonts(deck: PresentationHandle, fonts: FontFaceSet) {
27 const faces = new Map<number, Face>();
28 const names = new Map<string, string>();
29 const registered = new Set<string>();
30 const loads = new Map<string, Promise<void>>();
31 const settled = new Set<string>();
32​
33 /** Loads a face's bytes and browser face; the returned function registers both, so callers choose the order. */
34 const prepare = async (want: Want, requested: FontStyle) => {
35 const source = want.script
36 ? resolveScriptFallbackFace(want.script, requested.bold, requested.italic)
37 : presentationFace(want.family, requested.bold, requested.italic);
38​
39 if (!source) return;
40​
41 // A family without the requested style gets the face it has, which the browser then slants or emboldens. The engine
42 // draws a bold run with a family's regular face but never the reverse, so a heavier stand-in, such as Arial Black's
43 // bold one, registers at the requested style.
44 const style = {
45 bold: requested.bold && source.weight === 700,
46 italic: requested.italic && source.style === "italic",
47 };
48 // The worker holds this deck's faces alone, so the names only need to differ from each other.
49 const css = names.get(wantKey(want)) ?? `slide-${names.size}`;
50 const key = faceKey(want, style);
51​
52 names.set(wantKey(want), css);
53​
54 if (registered.has(key)) return;
55​
56 const buffer = await loadFace(source).catch(() => undefined);
57​
58 if (!buffer) return;
59​
60 const browser = await new FontFace(css, buffer, {
61 weight: style.bold ? "700" : "400",
62 style: style.italic ? "italic" : "normal",
63 })
64 .load()
65 .catch(() => undefined);
66​
67 if (!browser) return;
68​
69 return () => {
70 if (registered.has(key)) return;
71​
72 registered.add(key);
73 fonts.add(browser);
74​
75 const face = {
76 family: want.script ? css : want.family,
77 ...style,
78 bytes: new Uint8Array(buffer),
79 };
80​
81 faces.set(want.script ? deck.registerFallbackFont(face) : deck.registerFont(face), {
82 want,
83 style,
84 css,
85 });
86 };
87 };
88​
89 /** Loads and registers one face once; later requests share the first. */
90 const request = (want: Want, style: FontStyle) => {
91 const key = faceKey(want, style);
92 const existing = loads.get(key);
93​
94 if (existing) return existing;
95​
96 const load = prepare(want, style).then((register) => {
97 register?.();
98 settled.add(key);
99 });
100​
101 loads.set(key, load);
102​
103 return load;
104 };
105​
106 /** The faces a frame drew in a substitute style whose own face has not loaded or failed yet. */
107 const missing = (primitives: readonly SlidePrimitive[]) =>
108 textRuns(primitives).flatMap((run) => {
109 const face = faces.get(run.fontId);
110 const style = { bold: run.bold, italic: run.italic };
111​
112 if (!face || sameStyle(face.style, style) || settled.has(faceKey(face.want, style)))
113 return [];
114​
115 return [{ want: face.want, style }];
116 });
117​
118 const rename = (primitive: SlidePrimitive): SlidePrimitive => {
119 if (primitive.kind === "textBox")
120 return {
121 ...primitive,
122 lines: primitive.lines.map((line) => ({
123 ...line,
124 runs: line.runs.map((run) => ({
125 ...run,
126 fontFamily: faces.get(run.fontId)?.css ?? run.fontFamily,
127 // The engine places glyphs no bundled face has, such as Thai ones or emoji, a missing glyph's width apart,
128 // but the browser draws them from its own fonts. Without positions a run is drawn whole.
129 glyphs: run.glyphs.some((glyph) => glyph.glyphId === 0) ? [] : run.glyphs,
130 })),
131 })),
132 };
133​
134 if (primitive.kind === "table" || primitive.kind === "chart")
135 return { ...primitive, primitives: primitive.primitives.map(rename) };
136​
137 return primitive;
138 };
139​
140 return {
141 /**
142 * Registers the faces the deck's text names, in the order `text` ranks them: the engine draws every family it
143 * cannot find with the first. Resolves once each face has loaded or failed.
144 */
145 load: async (text: DeckText) => {
146 const regular = { bold: false, italic: false };
147 // The engine lays no text out without a face, so a deck that names none gets PowerPoint's own default.
148 const families =
149 text.families.length > 0 ? text.families : [{ name: "Calibri", styles: [regular] }];
150​
151 const wants: { want: Want; style: FontStyle }[] = [
152 ...families.flatMap((family) =>
153 family.styles.map((style) => ({ want: { family: family.name }, style })),
154 ),
155 ...text.scripts.map((script) => ({ want: { script }, style: regular })),
156 ];
157​
158 const registers = await Promise.all(wants.map((entry) => prepare(entry.want, entry.style)));
159​
160 registers.forEach((register) => register?.());
161 wants.forEach((entry) => {
162 const key = faceKey(entry.want, entry.style);
163​
164 loads.set(key, Promise.resolve());
165 settled.add(key);
166 });
167 },
168​
169 /**
170 * Lays a slide out. When its text asks for a style a registered face lacks, such as a bold the title style
171 * inherits, that face loads and the slide lays out again. The frame names the browser's faces, ready to paint.
172 */
173 layout: async (index: number) => {
174 const settle = async (rounds: number): Promise<SlideDisplayList> => {
175 const frame = deck.layoutSlide(index);
176 const wanted = rounds === 0 ? [] : missing(frame.primitives);
177​
178 if (wanted.length === 0) return { ...frame, primitives: frame.primitives.map(rename) };
179​
180 await Promise.all(wanted.map((entry) => request(entry.want, entry.style)));
181​
182 return settle(rounds - 1);
183 };
184​
185 return settle(2);
186 },
187 };
189​
190function textRuns(primitives: readonly SlidePrimitive[]): PositionedTextRun[] {
191 return primitives.flatMap((primitive) => {
192 if (primitive.kind === "textBox") return primitive.lines.flatMap((line) => line.runs);
193​
194 if (primitive.kind === "table" || primitive.kind === "chart")
195 return textRuns(primitive.primitives);
196​
197 return [];
198 });
200​
201function wantKey(want: Want) {
202 return want.script ? `script:${want.script}` : `family:${want.family.toLowerCase()}`;
204​
205function faceKey(want: Want, style: FontStyle) {
206 return `${wantKey(want)}|${style.bold}|${style.italic}`;
208​
209function sameStyle(left: FontStyle, right: FontStyle) {
210 return left.bold === right.bold && left.italic === right.italic;