Saltar al contenido principal
Receta número 26

Recetario · Capítulo 10 · Salida e integración

Muestrario con todas sus fuentes cargadas antes de componer

Un muestrario de cuatro páginas compuesto una vez antes de tiempo, como prueba, y luego con las fuentes que piden la configuración y el texto ya cargadas.

En esta página
  • Muestra en inglés: aún no hay edición en español
  • Formato 180 × 240 mm
  • 1 columna
  • Ysabeau Office 11/15,5
  • IBM Plex Mono
  • Noto Serif Display
  • 4 páginas
  • Nivel
  • Postext 1.57.1
  • Compuesto en 4 ms
  • 188 líneas de código

En pocas palabras

Un folleto de cuatro páginas que muestra tres tipos de letra. Enseña por qué todas las fuentes deben terminar de cargarse antes de componer las páginas; si no, las líneas se cortan donde no deben.

Lo que vas a componer

House Specimen Nº 3, de la imprenta imaginaria Pellow Lane Press, es un muestrario de cuatro páginas, en inglés, para tres fuentes. En la cubierta, un campo azul ultramar lleva una Ag blanca en Noto Serif Display cursiva de 240 pt y dos líneas en monoespaciada con los nombres de las tres fuentes; debajo va el título. La página 2 recorre Ysabeau Office en cascada, de 7 a 14 pt, y compone pangramas en español, polaco y checo cuyas ż, ř y ů necesitan un segundo archivo. La página 3 es la auditoría: una tabla en IBM Plex Mono con las diez fuentes que declara el cuadernillo, las seis con las que se componen sus páginas y los archivos que el navegador descargó para cada una. La página 4 repite el primer párrafo de la página 1 según una composición temprana y según la última. La temprana, hecha antes de que el navegador tuviera un solo archivo de fuente, corta las líneas en otros sitios, y algunas se salen de la medida.

Esta receta responde a

  • ¿Por qué cambian mis cortes de línea o se solapan las palabras en el PDF, y cómo cargo bien las fuentes?
  • ¿Cómo uso mis fuentes corporativas o con licencia en la composición y las incrusto en el PDF?
  • ¿Cómo averiguo qué falla en mi documento (avisos, desbordamientos, composición que no converge)?

La respuesta corta

script.js · líneas 314–331en el código completo
// buildDocumentWithFonts starts with prepareFonts: it reads the config and the text for every
// face they ask for (text, headings, chips, table, captions, opener, running heads), in each
// weight and slant, and loads them for the characters the document sets. The page declares its
// files (declareFaces), so they load through document.fonts; a face nothing declares would be
// asked of a resolve(family, weight, style) option. Then it builds, reads the faces the pages
// are set in, loads any that the config did not name and builds again.
let report; // { loaded, missing, synthesized }: lists of { family, weight, style }
const build = () => buildDocumentWithFonts(content(), config(),
  { onFonts: (found) => { report = found; } }); // what the last look at the pages found

kitStatus('Loading fonts…'); // the kit's bar: it also reports any error thrown below
const early = buildDocument(content(), config()); // on purpose: the page has no font yet (page 4)
declareFaces(FONTS);
const fitted = await build(); // every face loaded before a line is measured
audit = auditOf(fitted, report); // page 3's table
drawProof(early, fitted); // page 4's picture
const doc = await build(); // nothing left to load: the same pages, table and picture filled in
showPages(doc, { title: 'Load every font before layout' });

Ingredientes

Tipografía
Ysabeau Office, Noto Serif Display, IBM Plex Mono (SIL OFL 1.1)
Recursos
Ninguno: todas las imágenes se dibujan en código

Elaboración

#1 · Declara cada archivo sin descargarlo

script.js · líneas 268–287en el código completo
const SUBSETS = { // the characters each file covers, copied from the family's @font-face CSS
  latin: 'U+0000-00FF,U+0131,U+0152-0153,U+02BB-02BC,U+02C6,U+02DA,U+02DC,U+0304,U+0308,U+0329,'
    + 'U+2000-206F,U+20AC,U+2122,U+2191,U+2193,U+2212,U+2215,U+FEFF,U+FFFD',
  'latin-ext': 'U+0100-02BA,U+02BD-02C5,U+02C7-02CC,U+02CE-02D7,U+02DD-02FF,U+0304,U+0308,U+0329,'
    + 'U+1D00-1DBF,U+1E00-1E9F,U+1EF2-1EFF,U+2020,U+20A0-20AB,U+20AD-20C0,U+2113,U+2C60-2C7F,'
    + 'U+A720-A7FF' };
const FILES = new Map(); // FontFace → the subset its file covers, for the audit
function declareFaces(fonts) { // Fontsource's static files stand in for your own /fonts/ folder
  for (const { family, weight, style } of facesOf(fonts)) {
    const id = family.toLowerCase().replaceAll(' ', '-');
    for (const [subset, unicodeRange] of Object.entries(SUBSETS)) {
      const file = `${id}@5/files/${id}-${subset}-${weight}-${style}.woff2`;
      // Adding a face fetches nothing: the file downloads when a load or a line needs it.
      const face = new FontFace(family, `url(https://cdn.jsdelivr.net/npm/@fontsource/${file})`,
        { weight: `${weight}`, style, unicodeRange });
      FILES.set(face, subset);
      document.fonts.add(face);
    }
  }
}

Un FontFace corresponde a un archivo, igual que una regla @font-face, así que una fuente con un archivo latin y otro latin-ext se declara con dos objetos FontFace que comparten familia, peso y estilo y solo se distinguen por el unicodeRange, copiado del CSS de la familia. Añadirlos a document.fonts no descarga nada: el navegador trae cada archivo cuando una llamada a load() o una línea de texto necesita sus caracteres. Postext carga a través de document.fonts las fuentes que la página declara; las que nadie declara se las pide a la opción resolve, que es como las demás recetas reciben del kit sus archivos de Fontsource. customFonts en la configuración se limita a describir los archivos de un paquete .postext, así que una página compuesta a partir de Markdown declara los suyos o entrega un resolve.

#2 · Carga las fuentes y luego compón

El código es la respuesta corta de arriba. buildDocumentWithFonts empieza por prepareFonts, que lee en la configuración y en el texto todas las fuentes que piden, en cada peso y estilo, y las carga con los caracteres del propio documento como muestra, de modo que los archivos latin-ext llegan con los pangramas en polaco y en checo (Cargar las fuentes antes de componer). Después compone, lee con qué fuentes han quedado compuestas las páginas, carga las que la configuración no nombraba y vuelve a componer. onFonts recibe el informe de esa última revisión: las fuentes cargadas (loaded), las que faltan (missing) y las que el navegador habría imitado a partir de otro peso o estilo (synthesized). El pen compone tres veces porque el cuadernillo imprime su propia prueba: una vez antes de tiempo, otra con las fuentes y una última con la tabla y la imagen ya rellenas.

#3 · Saca la auditoría del informe

script.js · líneas 291–309en el código completo
const SET = { loaded: 'yes', synthesized: 'faked', missing: 'in a fallback' }; // the report
const nameOf = (f) => `${f.family.replaceAll('"', '')} ${f.weight} ${f.style}`; // or a FontFace
function auditOf(doc, report) {
  const found = Object.keys(SET).flatMap((kind) => report[kind].map((f) => [nameOf(f), kind]));
  const inPages = new Map(found);
  const loaded = [...FILES].filter(([face]) => face.status === 'loaded');
  const faces = new Map([...facesOf(FONTS), ...Object.keys(SET).flatMap((kind) => report[kind])]
    .map((f) => [nameOf(f), f])); // the declared faces, then any the pages set without a file
  const rows = [...faces].map(([name, f], i, all) => [
    i && all[i - 1][1].family === f.family ? '' : f.family, // each family named once
    `${f.weight}${f.style === 'italic' ? ' italic' : ''}`, SET[inPages.get(name)] ?? 'no',
    loaded.filter(([face]) => nameOf(face) === name).map(([, subset]) => subset).join(' · ')
      || 'none'].map((cell) => ({ content: cell })));
  // What else to read in a finished layout: its content warnings, its passes, its warnings.
  return { rows, note: `${report.loaded.length} of ${rows.length} faces set in the pages · `
    + `${loaded.length} of ${FILES.size} files fetched · fontFallback warnings: `
    + `${fallbacksIn(doc) || 'none'} · ${doc.converged ? '' : 'not '}converged · layout warnings: `
    + `${doc.warnings?.length || 'none'}` };
}

La tabla parte de las fuentes que declara FONTS y añade lo que el informe dice de cada una: si las páginas componen algo con ella, si el navegador la imitó o si salió en una fuente de reserva. La última columna enumera los archivos cuyo FontFace llegó a loaded. Se descargaron dieciséis de los veinte: Postext carga las cuatro variantes de la familia del texto, porque ** y * pueden pedirlas en cualquier párrafo, y las dos cursivas de la monoespaciada, que ningún ajuste pide, no llegaron a descargarse. La nota lee tres cosas más del documento terminado: contentWarnings, donde una fuente medida con una de reserva aparece como fontFallback; converged, que vale true cuando las pasadas de la composición se estabilizaron, y warnings. Comprueba las tres antes de mostrar o exportar una página.

#4 · Guarda una composición temprana como prueba

script.js · líneas 126–174en el código completo
const STRIP = { lines: 8, overrun: 10 }; // page 1's first paragraph; mm shown past the measure
const PROOF = { // px: two strips a lead apart, cut at 300 dpi
  width: Math.round(((MEASURE + STRIP.overrun) / 25.4) * 2 * DPI),
  height: Math.round((((2 * STRIP.lines + 1) * LEAD) / 72) * 2 * DPI) };
const proof = { moved: 0, total: 0, faces: 0 }; // lines the early build broke elsewhere, of all
const fallbacksIn = (doc) => // a build lists each face its font set could not give
  (doc.contentWarnings ?? []).filter((w) => w.kind === 'fontFallback').length;
const proofFigure = () => ({ id: 'proof', typeId: 'figure', kind: 'bitmap', createdAt: 0,
  updatedAt: 0, placement: here,
  bitmap: { fileId: 'proof.png', format: 'png', width: PROOF.width, height: PROOF.height },
  caption: 'The first paragraph of page 1 as the early build set it, measured before the fonts '
    + 'had arrived (above), and as the last build set it (below). The early build broke '
    + `${proof.moved} of its ${proof.total} lines of text elsewhere, and its own warnings name `
    + `${proof.faces} faces set in a fallback. The rule marks the measure.`,
  altText: `Two strips of the same ${STRIP.lines} lines of text. In the upper strip the lines `
    + 'break in other places and some run past a vertical rule; in the lower one every line '
    + 'stops short of it.' });
function drawProof(first, last) {
  const linesOf = (doc) => doc.blocks.filter((b) => b.type === 'paragraph')
    .map((b) => b.lines.map((l) => l.text));
  const [before, after] = [first, last].map(linesOf);
  proof.total = before.flat().length;
  proof.faces = fallbacksIn(first);
  proof.moved = before.flatMap((lines, i) => lines.filter((t, j) => t !== after[i]?.[j])).length;
  const canvas = Object.assign(document.createElement('canvas'), PROOF);
  const ctx = canvas.getContext('2d');
  const strip = (PROOF.height * STRIP.lines) / (2 * STRIP.lines + 1);
  const edge = Math.round((PROOF.width * MEASURE) / (MEASURE + STRIP.overrun));
  // The renderer clips each column 2 pt past its edge, which would cut the early build's lines
  // at the measure: paint a copy of page 1 whose column reaches across the whole strip.
  const wide = (column) => ({ ...column,
    bbox: { ...column.bbox, width: column.bbox.width + (STRIP.overrun / 25.4) * DPI } });
  [first, last].forEach((doc, i) => {
    const page = document.createElement('canvas');
    renderPageToCanvas({ ...doc.pages[0], columns: doc.pages[0].columns.map(wide) }, doc, page,
      { scale: 2 }); // 300 dpi
    const { x, y } = doc.pages[0].columns[0].blocks.find((b) => b.type === 'paragraph').bbox;
    ctx.drawImage(page, 2 * x, 2 * y, PROOF.width, strip,
      0, i * (PROOF.height - strip), PROOF.width, strip);
  });
  ctx.fillStyle = `${palette.ultramarine}1f`; // a pale wash over the margin past the measure
  ctx.fillRect(edge, 0, PROOF.width - edge, PROOF.height);
  ctx.fillStyle = palette.ultramarine; // a hairline at the measure, and each strip's name
  ctx.fillRect(edge, 0, 2, PROOF.height);
  ctx.font = `700 ${(7 / 72) * 2 * DPI}px "IBM Plex Mono"`; // 7 pt, loaded by now
  ['early', 'last'].forEach((name, i) => // on the last line of each strip
    ctx.fillText(name, edge + 12, (i ? PROOF.height : strip) - 16));
  registerResourceImage('proof.png', canvas);
}

El pen llama una vez a buildDocument antes de declarar ninguna fuente, así que esa composición mide todas las palabras con la fuente de reserva del navegador. Cuando ya han llegado las fuentes reales, el pen la vuelve a pintar y la compara línea a línea con la última; de esa comparación sale el número de líneas del pie, y el de fuentes, de los avisos fontFallback de la propia composición temprana. Una línea sin estilos, medida con una fuente de reserva más estrecha, se sale de la medida hasta que el recorte de la columna, 2 pt más allá de su borde, le corta las últimas letras; por eso el pen pinta la página 1 con la columna ensanchada, para que se vea todo lo que desborda. El canvas y postext-pdf dibujan cada tramo de una línea justificada o con estilos mezclados donde lo midió la composición, así que una fuente real más ancha que la de reserva se monta sobre la palabra siguiente, y en un PDF compuesto antes de que lleguen las fuentes las palabras acaban solapadas. Nada de la composición temprana pasa a la siguiente: prepareFonts encuentra las fuentes nuevas en document.fonts y descarta los anchos medidos en sus familias, así que no hace falta llamar a clearMeasurementCache().

#5 · Una cascada al ritmo del texto

script.js · líneas 30–44en el código completo
const bodyText = () => ({
  fontFamily: TEXT, fontSize: pt(11), lineHeight: pt(LEAD), color: col('ink'),
  boldColor: col('ink'), italicColor: col('ink'), referenceColor: col('ink'),
  textAlign: 'left', firstLineIndent: pt(0), paragraphSpacing: true }); // ragged and spaced
// Every waterfall size and pangram is two leads (31 pt) deep, on the text's 15.5 pt rhythm.
const line = (size) => ({ fontSize: pt(size), lineHeight: pt(2 * LEAD) });
const paragraphStyles = () => [
  ...[7, 8, 9, 10, 11, 12, 14].map((size) => ({ id: `s${size}`, ...line(size) })),
  { id: 'pangram', ...line(13) },
  { id: 'colophon', fontSize: pt(7), lineHeight: pt(10), fontFamily: MONO, color: col('muted') }];
// Size labels: boxless mono chips. A Plex Mono letter is 0.6 em wide, so a one-digit label gets
// half a letter each side and the samples start on one edge.
const tag = { fontFamily: MONO, fontSize: pt(7), color: col('ultramarine'),
  backgroundEnabled: false, borderWidth: pt(0), paddingX: pt(0), gap: mm(2.5) };
const chipStyles = () => [{ id: 'size', ...tag }, { id: 'size-1', ...tag, paddingX: em(0.3) }];

Ysabeau Office compone el texto en cuerpo 11 sobre 15,5 pt, con una línea en blanco entre párrafos en lugar de sangría, y en bandera, para que cada espacio entre palabras conserve su ancho natural. La negrita, la cursiva y las referencias van en el color del texto; por omisión tomarían el color principal. Cada cuerpo de la cascada y cada pangrama es un estilo de párrafo de dos interlineados (31 pt), así que la página conserva el ritmo de 15,5 pt del texto. Los cuerpos se rotulan con chips en monoespaciada, y los de una sola cifra llevan media letra de relleno a cada lado para que todas las muestras empiecen en el mismo borde.

#6 · Tres fuentes en una cubierta

script.js · líneas 48–74en el código completo
const Y = { kicker: 14, glyphs: 17, label: FIELD - 12, title: FIELD + 10, // mm from the top edge
  end: FIELD + 42 }; // where the opener ends: under the title, the lead and a line of air
const ITALIC_FOOT = 5; // mm: the italic A's foot reaches this far left of the glyphs' origin
const at = (x, y, width) => ({ anchor: { to: 'page', edge: 'top-left' },
  offset: { x: mm(x), y: mm(y) }, ...(width && { size: { width: mm(width) } }) });
const text = (id, content, style, placement) => ({ kind: 'text', id, content, align: 'left',
  overflow: 'wrap', ...style, placement }); // a running head wraps too, never '…'
const cover = () => ({ level: 1, fontSize: pt(30), italic: true, // headings.levels[0]
  breakBefore: { enabled: true, parity: 'odd' }, // the cover is a recto
  span: 'page', // the heading is set across the page; its field hangs from the bleed
  advancedDesign: { enabled: true, minHeight: mm(Y.end - MARGIN.top), // from the top margin
    slot: { elements: [
      { kind: 'box', id: 'field', style: { backgroundColor: col('ultramarine') }, placement: {
        anchor: { to: 'bleed', edge: 'top-left' }, size: { width: 'fill', height: mm(FIELD) } } },
      text('kicker', '{attr.kicker}', { ...label, fontWeight: 700, color: col('paper') },
        at(MARGIN.inner, Y.kicker)),
      text('glyphs', '{attr.glyphs}', { ...display, fontSize: pt(240), lineHeight: 1,
        color: col('paper') }, at(MARGIN.inner + ITALIC_FOOT, Y.glyphs)),
      text('label', '{attr.label}', { ...label, color: col('mist') }, at(MARGIN.inner, Y.label)),
      text('faces', '{attr.faces}', { ...label, color: col('mist') },
        { anchor: { to: '#label', edge: 'below' }, offset: { y: mm(1.2) } }),
      text('title', '{titleText}', { ...display, fontSize: pt(30), lineHeight: 1.05,
        color: col('ink') }, at(MARGIN.inner, Y.title, PAGE.width - 2 * MARGIN.inner)),
      text('lead', '{attr.lead}', { fontFamily: TEXT, italic: true, fontSize: pt(12),
        lineHeight: 1.35, color: col('ink') }, { anchor: { to: '#title', edge: 'below' },
        offset: { y: mm(3) }, size: { width: mm(MEASURE) } }),
    ] } } });

La cubierta es el diseño del nivel H1: las letras del atributo glyphs del título, en la fuente de titulares a 240 pt, y debajo dos líneas en monoespaciada que dan el nombre de esa fuente y de las de texto y etiquetas, como en el muestrario de una fundición tipográfica. span: 'page' extiende el título a toda la página, y el campo cuelga de la esquina superior izquierda del sangrado, así que sale por el borde superior. minHeight se cuenta desde el margen superior y reserva el espacio hasta Y.end, 42 mm por debajo del campo; sin él, el texto empieza una línea más arriba, pegado a la entradilla.

La receta completa

Sandbox
// ═══ Postext Cookbook · Nº 026 · Type specimen with every font loaded before layout ═════════
// https://postext.dev/en/cookbook/fonts-before-layout
// Code: MIT · Text: original (CC BY 4.0) · Picture: cut from the pen's own early and last builds
// Fonts: Ysabeau Office, Noto Serif Display, IBM Plex Mono (SIL OFL 1.1) · Needs postext ≥ 1.25.0
import { buildDocument, buildDocumentWithFonts, renderPageToCanvas, defaultResourceTypes,
  registerResourceImage } from 'https://esm.sh/postext';

const LANG = 'en'; // @lang: the language of the sample document ('en' | 'es')
const RECIPE = 'fonts-before-layout';

// ─── 1 · Design ─────────────────────────────────────────────────────────────
const PAGE = { width: 180, height: 240 }; // mm
const MARGIN = { top: 22, bottom: 24, inner: 20, outer: 48 }; // mm: inner is the spine side
const MEASURE = PAGE.width - MARGIN.inner - MARGIN.outer; // 112 mm: about 70 letters at 11 pt
const FIELD = 122; // mm from the top edge: the ultramarine field of the opener
const LEAD = 15.5; // pt: the body leading and the step of every vertical space
const DPI = 150; // the page's resolution: the proof on page 4 is cut at twice this
const [TEXT, DISPLAY, MONO] = ['Ysabeau Office', 'Noto Serif Display', 'IBM Plex Mono'];
const palette = { ink: '#16161a', ultramarine: '#3246d3', mist: '#c9d0f6', // mist: 4.6:1 on
  rule: '#cfc9bd', muted: '#6b6a70', paper: '#ffffff' }; // ultramarine, for labels on the field
// Every colour is linked to its palette entry; main-color catches any default left unstated.
const col = (id) => ({ hex: palette[id], model: 'hex', paletteId: id });
const colorPalette = () => Object.entries({ ...palette, 'main-color': palette.ultramarine })
  .map(([id, hex]) => ({ id, name: id, value: { hex, model: 'hex' } }));
const label = { fontFamily: MONO, fontSize: pt(7.5), letterSpacing: pt(1.2),
  textTransform: 'uppercase' };
const display = { fontFamily: DISPLAY, fontWeight: 900, italic: true };

// #region type: the text face at 11 on 15.5 pt, and a waterfall of it on two leads a line
const bodyText = () => ({
  fontFamily: TEXT, fontSize: pt(11), lineHeight: pt(LEAD), color: col('ink'),
  boldColor: col('ink'), italicColor: col('ink'), referenceColor: col('ink'),
  textAlign: 'left', firstLineIndent: pt(0), paragraphSpacing: true }); // ragged and spaced
// Every waterfall size and pangram is two leads (31 pt) deep, on the text's 15.5 pt rhythm.
const line = (size) => ({ fontSize: pt(size), lineHeight: pt(2 * LEAD) });
const paragraphStyles = () => [
  ...[7, 8, 9, 10, 11, 12, 14].map((size) => ({ id: `s${size}`, ...line(size) })),
  { id: 'pangram', ...line(13) },
  { id: 'colophon', fontSize: pt(7), lineHeight: pt(10), fontFamily: MONO, color: col('muted') }];
// Size labels: boxless mono chips. A Plex Mono letter is 0.6 em wide, so a one-digit label gets
// half a letter each side and the samples start on one edge.
const tag = { fontFamily: MONO, fontSize: pt(7), color: col('ultramarine'),
  backgroundEnabled: false, borderWidth: pt(0), paddingX: pt(0), gap: mm(2.5) };
const chipStyles = () => [{ id: 'size', ...tag }, { id: 'size-1', ...tag, paddingX: em(0.3) }];
// #endregion

// #region opener: the H1 as a bleed field, the display face at 240 pt, labels naming the faces
const Y = { kicker: 14, glyphs: 17, label: FIELD - 12, title: FIELD + 10, // mm from the top edge

El script.js compuesto funciona tal cual: pégalo como script de módulo en cualquier página o abre la receta en CodePen. Carpeta de la receta en GitHub ↗ (se abre en una nueva pestaña)

Variantes

#Entrega los archivos con resolve

kitFonts(FONTS), en de una cadena Markdown a una página diseñada, no declara nada: Postext pide a su resolve los archivos de cada fuente y los añade él mismo a document.fonts.

#Olvida una fuente

Quita la negrita de IBM Plex Mono, que compone el antetítulo, la fila de cabecera de la tabla y las etiquetas de los pies: el navegador engrosa la redonda, la tabla marca la fuente con «faked» y la nota cuenta un aviso fontFallback, que cita IBM Plex Mono 700 como synthesized.

-  'IBM Plex Mono': ['400', '400i', '700', '700i'], // labels, chips, the table, captions
+  'IBM Plex Mono': ['400', '400i', '700i'], // labels, chips, the table, captions

#Incrusta las mismas fuentes en un PDF

renderToPdf incrusta los bytes que su fontProvider devuelve para cada fuente, y el de un PDF de verdad con las mismas fuentes incrustadas sirve los archivos latin de Fontsource, que no pasan del Latin-1: para las ż, ł, ř y ů de este cuadernillo, haz que devuelva el archivo completo de cada fuente desde tu propia carpeta.

Errores frecuentes

Error frecuente

Los archivos de Fontsource cubren letras, no símbolos

El kit incrusta el archivo latin de Fontsource de cada fuente y, cuando el texto los usa, su archivo latin-ext para č, ł, † y su archivo greek para α, χ (en una familia que lo tenga: Lora y Gelasio no), en pantalla y en el PDF. Símbolos como →, ≈, ✓ y ★ no están en ninguno de esos archivos y faltan en el PDF: dibújalos, escríbelos como matemáticas o elige una fuente cuyos archivos los tengan. Fuentes incrustadas en el PDF →

Aviso de maquetación · fontFallback

Fuente sustituida en la composición

Por qué. Una fuente con la que se compuso el texto no estaba en el conjunto de fuentes cuando se compuso el documento (`reason: 'missing'`), o la familia no tiene archivo para ese peso o esa inclinación y el navegador la dibuja a partir de otra (`'synthesized'`), así que los cortes de línea se midieron con una fuente que no es la que incrusta el PDF.

Solución. Carga las fuentes antes de la primera composición: `prepareFonts(content, config, { resolve })`, o compón con `buildDocumentWithFonts`, que además carga cualquier fuente que hayan usado las páginas y vuelve a componer. Para `synthesized`, carga ese peso o esa inclinación, o elige un peso que la familia tenga. Documentación →

Comprobación del Sandbox · missingFont

Fuente no cargada

Por qué. Una familia indicada en la configuración no llegó a cargarse en el navegador, así que el texto se midió y se dibujó con una fuente de reserva del sistema.

Solución. Corrige el nombre de la familia (una sola familia, sin pila CSS) y carga todas las fuentes antes de la primera composición; en un pen, añádela a FONTS. Documentación →

Comprobación del Sandbox · missingFontVariant

Falta una variante de la fuente

Por qué. A una familia propia le falta el archivo de un peso y estilo que usa el documento, como su cursiva o su negrita.

Solución. Sube o declara la variante que falta, o deja de usar ese peso o estilo. Documentación →

  • Si cargas una fuente por tu cuenta, document.fonts.load(font) sin texto de muestra solo carga el archivo que cubre el espacio, el latin, y la ż y la ř salen en una fuente del sistema. prepareFonts pasa los caracteres del propio documento.
  • renderPageToCanvas y postext-pdf recortan cada columna 2 pt más allá de su borde, así que una línea medida con una fuente de reserva más estrecha pierde sus últimas letras. La composición que la midió registra la fuente en doc.contentWarnings como fontFallback: lee esa lista antes de mostrar o exportar una página.

Créditos

Texto
Texto original, CC BY 4.0
Fuentes
Ysabeau Office (SIL OFL 1.1) · Noto Serif Display (SIL OFL 1.1) · IBM Plex Mono (SIL OFL 1.1)
Sandbox