En poques paraules
Un fullet de quatre pàgines que mostra tres tipus de lletra. Ensenya per què totes les fonts han d'acabar de carregar-se abans de compondre les pàgines; si no, les línies es tallen on no toca.
Què compondràs
House Specimen Nº 3, de la impremta imaginària Pellow Lane Press, és un mostrari de quatre pàgines, en anglès, per a tres fonts. A la coberta, un camp blau ultramar porta una Ag blanca en Noto Serif Display cursiva de 240 pt i dues línies en monoespaiada amb els noms de les tres fonts; a sota va el títol. La pàgina 2 recorre Ysabeau Office en cascada, de 7 a 14 pt, i compon pangrames en espanyol, polonès i txec, amb les ż, ř i ů que necessiten un segon fitxer. La pàgina 3 és l'auditoria: una taula en IBM Plex Mono amb les deu fonts que declara el quadernet, les sis amb què es componen les seves pàgines i els fitxers que el navegador va baixar per a cada una. La pàgina 4 repeteix el primer paràgraf de la pàgina 1 segons una composició primerenca i segons l'última. La primerenca, feta abans que el navegador tingués cap fitxer de font, talla les línies en altres llocs, i algunes surten de la mesura.
Aquesta recepta respon a
- Per què canvien els meus talls de línia o se solapen les paraules al PDF, i com carrego bé les fonts?
- Com faig servir les meves fonts corporatives o amb llicència en la composició i les incrusto al PDF?
- Com esbrino què falla en el meu document (avisos, desbordaments, composició que no convergeix)?
La resposta curta
// 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' });
Ingredients
- Funcions
- Fonts abans de compondreTipografia del textPàgines en un canvasFigures i taules com a recursosFigures just aquíTaules a partir de dadesEstil de taulesEstil dels peusTipus de recurs propisObertures dissenyadesAtributs de títolAncoratge d'elements de dissenyEstils de paràgrafChips en líniaFormat de pàginaMarges simètricsPaleta de color semànticaCapçaleres i folisCapçaleres segons el tipus de pàgina
- També fa servir
- Figura i Taula en la teva llenguaBanda de capítol d'amplada completaSalts de pàgina i de columna
- Tipografia
- Ysabeau Office, Noto Serif Display, IBM Plex Mono (SIL OFL 1.1)
- Recursos
- Cap: totes les imatges es dibuixen en codi
Elaboració
#1 · Declara cada fitxer sense baixar-lo
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 correspon a un fitxer, igual que una regla @font-face, així que una font amb un fitxer latin i un altre de latin-ext es declara amb dos objectes FontFace que comparteixen família, gruix i estil i només es distingeixen pel unicodeRange, copiat del CSS de la família. Afegir-los a document.fonts no baixa res: el navegador baixa cada fitxer quan una crida a load() o una línia de text necessita els seus caràcters. Postext carrega a través de document.fonts les fonts que la pàgina declara; les que ningú declara les demana a l'opció resolve, que és com les altres receptes reben del kit els seus fitxers de Fontsource. customFonts a la configuració es limita a descriure els fitxers d'un paquet .postext, així que una pàgina composta a partir de Markdown declara els seus o lliura un resolve.
#2 · Carrega les fonts i després compon
El codi és la resposta curta de més amunt. buildDocumentWithFonts comença per prepareFonts, que llegeix a la configuració i al text totes les fonts que demanen, en cada gruix i estil, i les carrega amb els caràcters del mateix document com a mostra, de manera que els fitxers latin-ext arriben amb els pangrames en polonès i en txec (Carregar les fonts abans de compondre). Després compon, llegeix amb quines fonts han quedat compostes les pàgines, carrega les que la configuració no indicava i torna a compondre. onFonts rep l'informe d'aquesta última revisió: les fonts carregades (loaded), les que falten (missing) i les que el navegador hauria imitat a partir d'un altre gruix o estil (synthesized). El pen compon tres vegades perquè el quadernet imprimeix la seva pròpia prova: una vegada abans d'hora, una altra amb les fonts i una última amb la taula i la imatge ja omplertes.
#3 · Treu l'auditoria de l'informe
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 taula parteix de les fonts que declara FONTS i hi afegeix el que l'informe diu de cada una: si les pàgines componen res amb ella, si el navegador la va imitar o si va sortir en una font de reserva. L'última columna enumera els fitxers amb un FontFace que va arribar a loaded. Se'n van baixar setze dels vint: Postext carrega les quatre variants de la família del text, perquè ** i * les poden demanar a qualsevol paràgraf, i les dues cursives de la monoespaiada, que cap paràmetre no indica, no es van arribar a baixar. La nota llegeix tres coses més del document acabat: contentWarnings, on una font mesurada amb una de reserva apareix com a fontFallback; converged, que val true quan les passades de la composició s'han estabilitzat, i warnings. Comprova-les totes tres abans de mostrar o exportar una pàgina.
#4 · Desa una composició primerenca com a prova
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 crida una vegada buildDocument abans de declarar cap font, així que aquesta composició mesura totes les paraules amb la font de reserva del navegador. Quan ja han arribat les fonts reals, el pen la torna a pintar i la compara línia a línia amb l'última; d'aquesta comparació surt el nombre de línies del peu, i el de fonts, dels avisos fontFallback de la mateixa composició primerenca. Una línia sense estils, mesurada amb una font de reserva més estreta, surt de la mesura fins que el retall de la columna, 2 pt més enllà de la seva vora, li talla les últimes lletres; per això el pen pinta la pàgina 1 amb la columna eixamplada, perquè es vegi tot el que desborda. El canvas i postext-pdf dibuixen cada tram d'una línia justificada o amb estils barrejats allà on el va mesurar la composició, així que una font real més ampla que la de reserva es munta sobre la paraula següent, i en un PDF compost abans que arribin les fonts les paraules acaben solapades. Res de la composició primerenca passa a la següent: prepareFonts troba les fonts noves a document.fonts i descarta les amplades mesurades en les seves famílies, així que no cal cridar clearMeasurementCache().
#5 · Una cascada al ritme del text
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 compon el text en cos 11 sobre 15,5 pt, amb una línia en blanc entre paràgrafs en lloc de sagnat, i en bandera, perquè cada espai entre paraules conservi la seva amplada natural. La negreta, la cursiva i les referències van en el color del text; per defecte prendrien el color principal. Cada cos de la cascada i cada pangrama és un estil de paràgraf de dos interlineats (31 pt), així que la pàgina conserva el ritme de 15,5 pt del text. Els cossos es retolen amb xips en monoespaiada, i els d'una sola xifra porten mitja lletra d'emplenament a cada costat perquè totes les mostres comencin a la mateixa vora.
#6 · Tres fonts en una coberta
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 coberta és el disseny del nivell H1: les lletres de l'atribut glyphs del títol, en la font de titulars a 240 pt, i a sota dues línies en monoespaiada que anomenen aquesta font i les de text i d'etiquetes, com en el mostrari d'una foneria tipogràfica. span: 'page' estén el títol a tota la pàgina, i el camp penja de la cantonada superior esquerra de la sang, així que surt per la vora superior. minHeight es compta des del marge superior i reserva l'espai fins a Y.end, 42 mm per sota del camp; sense aquest valor, el text comença una línia més amunt, enganxat a l'entradeta.
La recepta completa
// ═══ 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
L'script.js compost funciona tal com és: enganxa'l com a script de mòdul en qualsevol pàgina o obre la recepta a CodePen. Carpeta de la recepta a GitHub ↗ (s'obre en una pestanya nova)
Variants
#Lliura els fitxers amb resolve
kitFonts(FONTS), a d'una cadena Markdown a una pàgina dissenyada, no declara res: Postext demana al seu resolve els fitxers de cada font i els afegeix ell mateix a document.fonts.
#Oblida una font
Treu la negreta d'IBM Plex Mono, que compon l'avanttítol, la fila de capçalera de la taula i les etiquetes dels peus: el navegador engruixeix la rodona, la taula marca la font amb «faked» i la nota compta un avís fontFallback, que anomena IBM Plex Mono 700 com a 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 les mateixes fonts en un PDF
renderToPdf incrusta els bytes que el seu fontProvider retorna per a cada font, i el d'un PDF de debò amb les mateixes fonts incrustades serveix els fitxers latin de Fontsource, que no passen del Latin-1: per a les ż, ł, ř i ů d'aquest quadernet, fes que retorni el fitxer complet de cada font des de la teva pròpia carpeta.
Errors freqüents
Error freqüent
Els fitxers de Fontsource cobreixen lletres, no símbols
El kit incrusta el fitxer latin de Fontsource de cada font i, quan el text els fa servir, el seu fitxer latin-ext per a č, ł, † i el seu fitxer greek per a α, χ (en una família que en tingui: Lora i Gelasio no), a la pantalla i al PDF. Símbols com →, ≈, ✓ i ★ no són a cap d'aquests fitxers i falten al PDF: dibuixa'ls, escriu-los com a matemàtiques o tria una font els fitxers de la qual els tinguin. Fonts incrustades al PDF →
Avís de maquetació · fontFallback
Font substituïda a la composició
Per què. Una font amb què es va compondre el text no era al conjunt de fonts quan es va compondre el document (`reason: 'missing'`), o la família no té fitxer per a aquest gruix o aquesta inclinació i el navegador la dibuixa a partir d'una altra (`'synthesized'`), de manera que els talls de línia es van mesurar amb una font que no és la que incrusta el PDF.
Solució. Carrega les fonts abans de la primera composició: `prepareFonts(content, config, { resolve })`, o compon amb `buildDocumentWithFonts`, que a més carrega qualsevol font que hagin fet servir les pàgines i torna a compondre. Per a `synthesized`, carrega aquest gruix o aquesta inclinació, o tria un gruix que tingui la família. Documentació →
Comprovació del Sandbox · missingFont
Font no carregada
Per què. Una família que indica la configuració no s'ha arribat a carregar al navegador, de manera que el text s'ha mesurat i dibuixat amb una font de reserva del sistema.
Solució. Corregeix el nom de la família (una sola família, sense pila CSS) i carrega totes les fonts abans de la primera composició; en un pen, afegeix-la a FONTS. Documentació →
Comprovació del Sandbox · missingFontVariant
Falta una variant de font
Per què. A una família pròpia li falta el fitxer d'un gruix i un estil que fa servir el document, com ara la cursiva o la negreta.
Solució. Puja o declara la variant que falta, o deixa de fer servir aquest gruix o estil. Documentació →
- Si carregues una font pel teu compte,
document.fonts.load(font)sense text de mostra només carrega el fitxer que cobreix l'espai, el latin, i la ż i la ř surten en una font del sistema.prepareFontshi passa els caràcters del mateix document. renderPageToCanvasipostext-pdfretallen cada columna 2 pt més enllà de la seva vora, així que una línia mesurada amb una font de reserva més estreta perd les últimes lletres. La composició que la va mesurar anomena la font adoc.contentWarningscom afontFallback: llegeix aquesta llista abans de mostrar o exportar una pàgina.
Crèdits
- Recepta
- Ignacio Ferro
- Text
- Text original, CC BY 4.0
- Fonts
- Ysabeau Office (SIL OFL 1.1) · Noto Serif Display (SIL OFL 1.1) · IBM Plex Mono (SIL OFL 1.1)
- Codi
- MIT, com Postext
Editar aquest text ↗ (s'obre en una pestanya nova)Carpeta de la recepta a GitHub ↗ (s'obre en una pestanya nova)


