♻️ Replace Font type with PDFFont from pdf-core

The `Font` type was a thin wrapper around `PDFFont`, duplicating
properties (`key`, `style`, `weight`) that already exist on the
underlying `PDFFont` class. Consumers always dereferenced `.pdfFont`
to access the actual font object.

Remove the `Font` type and use `PDFFont` directly throughout the
codebase. `FontStore.selectFont()` now returns `PDFFont` instead of
`Font`, eliminating the wrapping logic in `_loadFont`.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: ralfstx

src/font-store.test.ts

@@ -59,8 +59,8 @@ describe('FontStore', () => {
       const selected1 = await store.selectFont({ fontFamily: 'Roboto' });
       const selected2 = await store.selectFont({ fontFamily: 'Roboto Light', fontStyle: 'italic' });
 
-      expect(selected1.pdfFont.fontName).toBe('Roboto');
-      expect(selected2.pdfFont.fontName).toBe('Roboto Light Italic');
+      expect(selected1.fontName).toBe('Roboto');
+      expect(selected2.fontName).toBe('Roboto Light Italic');
     });
 
     it('registers font with custom config', async () => {
@@ -75,8 +75,8 @@ describe('FontStore', () => {
       const selected1 = await store.selectFont({ fontFamily: 'Custom Name' });
       const selected2 = await store.selectFont({ fontFamily: 'Custom Name', fontWeight: 'bold' });
 
-      expect(selected1.pdfFont.fontName).toBe('Roboto Light Italic');
-      expect(selected2.pdfFont.fontName).toBe('Roboto');
+      expect(selected1.fontName).toBe('Roboto Light Italic');
+      expect(selected2.fontName).toBe('Roboto');
     });
   });
 
@@ -131,29 +131,29 @@ describe('FontStore', () => {
       const font3 = await store.selectFont({ fontFamily, fontStyle: 'italic' });
       const font4 = await store.selectFont({ fontFamily, fontStyle: 'italic', fontWeight: 'bold' });
 
-      expect(font1.pdfFont.fontName).toBe('MockFont:Test:normal:400');
-      expect(font2.pdfFont.fontName).toBe('MockFont:Test:normal:700');
-      expect(font3.pdfFont.fontName).toBe('MockFont:Test:italic:400');
-      expect(font4.pdfFont.fontName).toBe('MockFont:Test:italic:700');
+      expect(font1.fontName).toBe('MockFont:Test:normal:400');
+      expect(font2.fontName).toBe('MockFont:Test:normal:700');
+      expect(font3.fontName).toBe('MockFont:Test:italic:400');
+      expect(font4.fontName).toBe('MockFont:Test:italic:700');
     });
 
     it('selects first matching font if no family specified', async () => {
       const font1 = await store.selectFont({});
-      expect(font1.pdfFont.fontName).toBe('MockFont:Test:normal:400');
+      expect(font1.fontName).toBe('MockFont:Test:normal:400');
 
       const font2 = await store.selectFont({ fontWeight: 'bold' });
-      expect(font2.pdfFont.fontName).toBe('MockFont:Test:normal:700');
+      expect(font2.fontName).toBe('MockFont:Test:normal:700');
 
       const font3 = await store.selectFont({ fontStyle: 'italic' });
-      expect(font3.pdfFont.fontName).toBe('MockFont:Test:italic:400');
+      expect(font3.fontName).toBe('MockFont:Test:italic:400');
 
       const font4 = await store.selectFont({ fontStyle: 'italic', fontWeight: 'bold' });
-      expect(font4.pdfFont.fontName).toBe('MockFont:Test:italic:700');
+      expect(font4.fontName).toBe('MockFont:Test:italic:700');
     });
 
     it('selects font with matching font family', async () => {
       await expect(store.selectFont({ fontFamily: 'Other' })).resolves.toEqual(
-        expect.objectContaining({ name: 'MockFont:Other:normal:400' }),
+        expect.objectContaining({ fontName: 'MockFont:Other:normal:400' }),
       );
     });
 
@@ -165,7 +165,7 @@ describe('FontStore', () => {
       registerFakeFont(store, 'Test', { style: 'oblique', weight: 700 });
 
       await expect(store.selectFont({ fontFamily: 'Test', fontStyle: 'italic' })).resolves.toEqual(
-        expect.objectContaining({ name: 'MockFont:Test:oblique:400' }),
+        expect.objectContaining({ fontName: 'MockFont:Test:oblique:400' }),
       );
     });
 
@@ -178,17 +178,15 @@ describe('FontStore', () => {
 
       const font = await store.selectFont({ fontFamily: 'Test', fontStyle: 'italic' });
 
-      expect(font.pdfFont).toEqual(
-        expect.objectContaining({ fontName: 'MockFont:Test:italic:400' }),
-      );
+      expect(font).toEqual(expect.objectContaining({ fontName: 'MockFont:Test:italic:400' }));
     });
 
     it('falls back when no matching font weight can be found', async () => {
       await expect(store.selectFont({ fontFamily: 'Other', fontWeight: 'bold' })).resolves.toEqual(
-        expect.objectContaining({ name: 'MockFont:Other:normal:400' }),
+        expect.objectContaining({ fontName: 'MockFont:Other:normal:400' }),
       );
       await expect(store.selectFont({ fontFamily: 'Other', fontWeight: 200 })).resolves.toEqual(
-        expect.objectContaining({ name: 'MockFont:Other:normal:400' }),
+        expect.objectContaining({ fontName: 'MockFont:Other:normal:400' }),
       );
     });
 

src/font-store.ts

@@ -1,14 +1,13 @@
-import { PDFEmbeddedFont } from '@ralfstx/pdf-core';
+import { PDFEmbeddedFont, type PDFFont } from '@ralfstx/pdf-core';
 
 import type { FontConfig } from './api/PdfMaker.ts';
 import type { FontWeight } from './api/text.ts';
-import type { Font, FontDef, FontSelector } from './fonts.ts';
+import type { FontDef, FontSelector } from './fonts.ts';
 import { weightToNumber } from './fonts.ts';
-import { pickDefined } from './types.ts';
 
 export class FontStore {
   readonly #fontDefs: FontDef[];
-  #fontCache: Record<string, Promise<Font>> = {};
+  #fontCache: Record<string, Promise<PDFFont>> = {};
 
   constructor() {
     this.#fontDefs = [];
@@ -23,33 +22,24 @@ export class FontStore {
     this.#fontCache = {}; // Invalidate cache
   }
 
-  async selectFont(selector: FontSelector): Promise<Font> {
+  async selectFont(selector: FontSelector): Promise<PDFFont> {
     const cacheKey = [
       selector.fontFamily ?? 'any',
       selector.fontStyle ?? 'normal',
       selector.fontWeight ?? 'normal',
     ].join(':');
     try {
-      return await (this.#fontCache[cacheKey] ??= this._loadFont(selector, cacheKey));
+      return await (this.#fontCache[cacheKey] ??= this._loadFont(selector));
     } catch (error) {
       const { fontFamily: family, fontStyle: style, fontWeight: weight } = selector;
       const selectorStr = `'${family}', style=${style ?? 'normal'}, weight=${weight ?? 'normal'}`;
       throw new Error(`Could not load font for ${selectorStr}`, { cause: error });
     }
   }
 
-  _loadFont(selector: FontSelector, key: string): Promise<Font> {
+  _loadFont(selector: FontSelector): Promise<PDFFont> {
     const selectedFontDef = selectFontDef(this.#fontDefs, selector);
-    const pdfFont = selectedFontDef.pdfFont ?? new PDFEmbeddedFont(selectedFontDef.data);
-    return Promise.resolve(
-      pickDefined({
-        key,
-        name: pdfFont.fontName ?? selectedFontDef.family,
-        style: selector.fontStyle ?? 'normal',
-        weight: weightToNumber(selector.fontWeight ?? 400),
-        pdfFont,
-      }),
-    );
+    return Promise.resolve(selectedFontDef.pdfFont ?? new PDFEmbeddedFont(selectedFontDef.data));
   }
 }
 

src/fonts.ts

@@ -1,4 +1,4 @@
-import type { PDFEmbeddedFont, PDFFont } from '@ralfstx/pdf-core';
+import type { PDFEmbeddedFont } from '@ralfstx/pdf-core';
 
 import type { FontStyle, FontWeight } from './api/text.ts';
 import { printValue } from './print-value.ts';
@@ -14,14 +14,6 @@ export type FontDef = {
   pdfFont?: PDFEmbeddedFont;
 };
 
-export type Font = {
-  key: string;
-  name: string;
-  style: FontStyle;
-  weight: number;
-  pdfFont: PDFFont;
-};
-
 export type FontSelector = {
   fontFamily?: string;
   fontStyle?: FontStyle;

src/frame.ts

@@ -1,6 +1,5 @@
-import type { PDFImage } from '@ralfstx/pdf-core';
+import type { PDFFont, PDFImage } from '@ralfstx/pdf-core';
 
-import type { Font } from './fonts.ts';
 import type { Color } from './read-color.ts';
 import type { PathCommand } from './svg-paths.ts';
 
@@ -37,7 +36,7 @@ export type TextRowObject = {
 
 export type TextSegmentObject = {
   text: string;
-  font: Font;
+  font: PDFFont;
   fontSize: number;
   color?: Color;
   rise?: number;

src/layout/layout-text.test.ts

@@ -1,15 +1,16 @@
+import type { PDFFont } from '@ralfstx/pdf-core';
 import { beforeEach, describe, expect, it } from 'vitest';
 
 import type { Box } from '../box.ts';
 import { rgb } from '../colors.ts';
 import { FontStore } from '../font-store.ts';
-import type { Font, FontSelector } from '../fonts.ts';
+import type { FontSelector } from '../fonts.ts';
 import type { MakerCtx } from '../maker-ctx.ts';
 import { extractTextRows, fakeFont, range, span } from '../test/test-utils.ts';
 import { layoutTextContent } from './layout-text.ts';
 
 describe('layout-text', () => {
-  let defaultFont: Font;
+  let defaultFont: PDFFont;
   let box: Box;
   let ctx: MakerCtx;
 

src/layout/layout-text.ts

@@ -1,5 +1,6 @@
+import type { PDFFont } from '@ralfstx/pdf-core';
+
 import type { Box, Size } from '../box.ts';
-import type { Font } from '../fonts.ts';
 import type { LinkObject, RenderObject, TextRowObject, TextSegmentObject } from '../frame.ts';
 import { createRowGuides } from '../guides.ts';
 import type { MakerCtx } from '../maker-ctx.ts';
@@ -136,8 +137,8 @@ function layoutTextRow(segments: TextSegment[], box: Box) {
   return { row, objects, remainder };
 }
 
-function getDescent(font: Font, fontSize: number) {
-  return Math.abs((font.pdfFont.descent * fontSize) / 1000);
+function getDescent(font: PDFFont, fontSize: number) {
+  return Math.abs((font.descent * fontSize) / 1000);
 }
 
 /**

src/render/render-page.test.ts

@@ -1,9 +1,8 @@
-import type { PDFDocument } from '@ralfstx/pdf-core';
+import type { PDFDocument, PDFFont } from '@ralfstx/pdf-core';
 import { PDFPage } from '@ralfstx/pdf-core';
 import { beforeEach, describe, expect, it, vi } from 'vitest';
 
 import type { Size } from '../box.ts';
-import type { Font } from '../fonts.ts';
 import type { Frame } from '../frame.ts';
 import type { Page } from '../page.ts';
 import { fakeFont, getContentStream } from '../test/test-utils.ts';
@@ -79,7 +78,7 @@ describe('render-page', () => {
   describe('renderFrame', () => {
     let page: Page;
     let size: Size;
-    let font: Font;
+    let font: PDFFont;
 
     beforeEach(() => {
       size = { width: 500, height: 800 };

src/render/render-text.test.ts

@@ -1,8 +1,8 @@
+import type { PDFFont } from '@ralfstx/pdf-core';
 import { PDFPage } from '@ralfstx/pdf-core';
 import { beforeEach, describe, expect, it } from 'vitest';
 
 import type { Size } from '../box.ts';
-import type { Font } from '../fonts.ts';
 import type { TextObject } from '../frame.ts';
 import type { Page } from '../page.ts';
 import { fakeFont, getContentStream } from '../test/test-utils.ts';
@@ -11,7 +11,7 @@ import { renderText } from './render-text.ts';
 describe('render-text', () => {
   let page: Page;
   let size: Size;
-  let font: Font;
+  let font: PDFFont;
 
   beforeEach(() => {
     size = { width: 500, height: 800 };

src/render/render-text.ts

@@ -18,12 +18,10 @@ export function renderText(object: TextObject, page: Page, base: Pos) {
   object.rows?.forEach((row) => {
     cs.setTextMatrix(1, 0, 0, 1, x + row.x, y - row.y - row.baseline);
     row.segments?.forEach((seg) => {
-      const pdfFont = seg.font.pdfFont;
-      if (!pdfFont) throw new Error('PDF font not initialized');
-      const glyphRun = pdfFont.shapeText(seg.text, { defaultFeatures: false });
+      const glyphRun = seg.font.shapeText(seg.text, { defaultFeatures: false });
 
       setTextColorOp(cs, state, seg.color);
-      setTextFontAndSizeOp(cs, state, pdfFont, seg.fontSize);
+      setTextFontAndSizeOp(cs, state, seg.font, seg.fontSize);
       setTextRiseOp(cs, state, seg.rise);
       setLetterSpacingOp(cs, state, seg.letterSpacing);
       cs.showPositionedText(glyphRun);

src/test/test-utils.ts

@@ -1,22 +1,15 @@
 import type { PDFFont } from '@ralfstx/pdf-core';
 import { PDFImage, PDFRef } from '@ralfstx/pdf-core';
 
-import type { Font } from '../fonts.ts';
+import type { FontWeight } from '../api/text.ts';
 import { weightToNumber } from '../fonts.ts';
 import type { Frame } from '../frame.ts';
 import type { Page } from '../page.ts';
 import type { TextAttrs, TextSpan } from '../read-block.ts';
 
-export function fakeFont(name: string, opts?: Partial<Omit<Font, 'name'>>): Font {
-  const key = `${name}-${opts?.style ?? 'normal'}-${opts?.weight ?? 400}`;
-  const font: Font = {
-    key,
-    name,
-    style: opts?.style ?? 'normal',
-    weight: weightToNumber(opts?.weight ?? 'normal'),
-    pdfFont: fakePdfFont(key),
-  };
-  return font;
+export function fakeFont(name: string, opts?: { style?: string; weight?: FontWeight }): PDFFont {
+  const key = `${name}-${opts?.style ?? 'normal'}-${weightToNumber(opts?.weight ?? 'normal')}`;
+  return fakePdfFont(key);
 }
 
 export function fakeImage(width: number, height: number): PDFImage {