En pocas palabras
Un editor en directo para una edición de bolsillo de La máquina del tiempo. Cada vez que escribes, la página se compone de nuevo en segundo plano, y la pantalla sigue respondiendo.
Lo que vas a componer
Compones el capítulo I de La máquina del tiempo, de H. G. Wells, en inglés, como libro de bolsillo de 110 × 147 mm, junto a su Markdown. La portada lleva la fotografía de un cuadrante de latón con cuatro esferas, generada con modelos de difusión, sobre un campo burdeos dibujado en código y, debajo, el título en Cinzel. El texto del capítulo empieza en la novena línea, bajo un número romano y un filete de latón, y va en Baskervville de 9,5/13 pt, con cabeceras en versalitas. Cada pulsación recompone el capítulo en un Web Worker, y a la derecha aparece la página donde está el cursor. Bajo el editor, una aguja que el hilo principal gira en cada fotograma se para mientras ese hilo está ocupado, y la línea de estado da la duración, el fotograma más largo y las composiciones que canceló una pulsación posterior. Un desplegable arriba a la derecha pasa la composición al hilo principal, para comparar.
Esta receta responde a
- ¿Cómo evito que la página se bloquee mientras se compone un libro largo (Web Worker, cancelación)?
- ¿Por qué cambian mis cortes de línea o se solapan las palabras en el PDF, y cómo cargo bien las fuentes?
- ¿Puedo generar páginas o PDF en un servidor o desde la línea de comandos (Node)?
La respuesta corta
async function startLayoutWorker(faces) {
// No options: from a CDN the engine starts its worker entry, at the page's own version,
// through a same-origin blob; in a bundle it starts the worker file next to the module.
const layout = createLayoutWorker();
// The worker measures with its own FontFaceSet, not the page's. Without the bytes of every
// face it measures in a fallback font, and the console names each missing family once.
const payloads = await Promise.all(faces.map(async ({ family, weight, style, url }) => {
// Check the status: a 404 page sent as a font only logs a warning inside the worker.
const response = await fetch(url);
if (!response.ok) throw new Error(`${family} ${weight} ${style}: HTTP ${response.status}`);
return { family, weight, style, buffer: await response.arrayBuffer() };
}));
await layout.registerFonts(payloads); // the buffers move to the worker, not copied
let inFlight = null;
return async function typeset(content) {
inFlight?.abort(); // cancel the build that the previous keystroke asked for
const build = (inFlight = new AbortController());
try {
return await layout.build(content, config(), { signal: build.signal });
} catch (error) {
if (error.name === 'AbortError') return null; // superseded: a newer build is on its way
throw error;
}
};
}
Ingredientes
- Funciones
- Composición en un Web WorkerFuentes antes de componerPáginas en un canvasFormato de páginaMárgenes simétricosTipografía del textoCapítulos que abren en página imparAperturas diseñadasTítulos numeradosEstilos de títuloCapítulos sin númeroCabeceras por secciónCabeceras y foliosCabeceras según el tipo de páginaImágenes en los diseños de páginaFiguras y tablas como recursosEstilos de párrafoColor del papelEspacio vertical explícito
- También usa
- Atributos de título
- Tipografía
- Baskervville, Baskervville SC, Cinzel (SIL OFL 1.1)
- Recursos
dial-1120.jpg- El cuadrante de latón de la portada, una fotografía (Generated With Diffusion Models, original)
- La tela burdeos y el marco dorado de la portada, dibujados en código con la paleta de la página (Ignacio Ferro, MIT)
Elaboración
#1 · Arranca el worker con una llamada
El código de este paso es la respuesta corta. createLayoutWorker() va sin opciones. Si el módulo viene de esm.sh, el archivo del worker es de otro origen y el constructor Worker lo rechazaría, así que el motor arranca su entrada de worker a través de un blob del origen de la página, en la misma versión que importó la página. En una aplicación empaquetada, la misma llamada arranca el archivo del worker que está junto al módulo. El objeto que devuelve tiene un build() que acepta el mismo contenido y la misma configuración que buildDocument() y se resuelve con el mismo tipo de documento (Ejecutar la composición en un Web Worker).
#2 · Carga cada fuente dos veces
const FONTS = { // every face the pages use: the page loads them, and so must the worker
Baskervville: ['400', '400i'], // text, folios, subtitle, colophon
'Baskervville SC': ['500'], // running heads, the author
Cinzel: ['700'], // title, numeral, chapter title
};
// The worker gets the same Fontsource files the page loads: identical metrics on both threads.
const faces = Object.entries(FONTS).flatMap(([family, specs]) => specs.map((spec) => {
const [id, weight, style] = [family.toLowerCase().replace(/ /g, '-'), parseInt(spec, 10),
spec.endsWith('i') ? 'italic' : 'normal'];
const file = `${id}@5/files/${id}-latin-${weight}-${style}.woff2`;
return { family, weight: String(weight), style,
url: `https://cdn.jsdelivr.net/npm/@fontsource/${file}` };
}));
El worker tiene su propio FontFaceSet y no ve las fuentes que ha cargado la página, así que la respuesta corta descarga los mismos archivos de Fontsource y pasa sus bytes a registerFonts(), con el peso como cadena ('400'). Si quitas esa llamada, el worker mide con una fuente de reserva: compone este capítulo en 175 líneas en vez de 190, ya la primera línea termina en «him)» en lugar de en «of», y la consola de la página cita una vez cada familia que falta. Un archivo que no se descarga se ve peor. Si al worker le llega una página 404 en lugar de la Baskervville redonda, registerFonts() se resuelve igual y el capítulo sale en 186 líneas, con un aviso solo en la consola del worker. Por eso la respuesta corta comprueba el código HTTP de cada descarga antes de enviar ningún byte, y si alguna falla lanza un error con la fuente y el código. La página carga además las mismas fuentes con loadFonts(), porque el canvas pinta con las de la página.
#3 · Compón en cada pulsación, pinta en el hilo principal
let [doc, shown, builds, cancelled] = [null, 0, 0, 0];
// For the comparison, the main thread keeps a measurement cache between keystrokes, as the
// worker does: both threads then time a build that measures only what changed.
const mainCache = createMeasurementCache();
function paint(n = shown) { // the canvas is sized to its box, in device pixels
shown = Math.max(0, Math.min(doc.pages.length - 1, n));
const vdtPage = doc.pages[shown]; // a laid-out page, not the page config above
const height = ($('proof').clientHeight || 640) * Math.min(devicePixelRatio || 1, 2);
renderPageToCanvas(vdtPage, doc, $('proof'), { scale: height / vdtPage.height });
$('proof').setAttribute('aria-label', `Page ${vdtPage.pageLabel}`);
$('folio').value = `${shown + 1} / ${doc.pages.length}`;
}
function follow() { // turn to the page that holds the caret: every block keeps its source offset
const caret = $('source').selectionStart;
paint(doc.pages.findLastIndex((vdtPage) => vdtPage.columns.some((column) =>
column.blocks.some((block) => block.sourceStart <= caret))));
}
async function refresh() {
const [ticket, onMain, started] = [++builds, $('thread').value === 'main', performance.now()];
frames.worst = 0;
const content = { markdown: $('source').value, resources };
const next = onMain ? buildDocument(content, config(), mainCache) : await typeset(content);
await new Promise(requestAnimationFrame); // the first frame after the build shows any stall
if (!next || ticket !== builds) { cancelled++; return; } // a newer build has been asked for
doc = next;
if (document.activeElement === $('source')) follow(); else paint();
showPages(doc, { title: 'The Time Machine · chapter I, set in a Web Worker' });
$('clock').value = `${onMain ? 'Main thread' : 'Worker'} · ${doc.pages.length} pages in `
+ `${Math.round(performance.now() - started)} ms · longest frame ${Math.round(frames.worst)}`
+ ` ms · ${builds} ${builds === 1 ? 'build' : 'builds'}, ${cancelled} cancelled`;
}
$('source').addEventListener('input', refresh);
for (const type of ['click', 'keyup']) $('source').addEventListener(type, () => doc && follow());
$('thread').addEventListener('change', refresh);
$('prev').addEventListener('click', () => paint(shown - 1));
$('next').addEventListener('click', () => paint(shown + 1));
// A dial the main thread turns on every frame: it stops while that thread is busy.
const frames = { last: 0, worst: 0 };
requestAnimationFrame(function turn() { // the clock, not the frame's timestamp: a late frame
const now = performance.now(); // keeps the time it was due, which hides the stall
frames.worst = Math.max(frames.worst, now - (frames.last || now));
frames.last = now;
const deg = ((now * 0.06) % 360).toFixed(1); // a turn in 6 s
$('hand').setAttribute('transform', `rotate(${deg})`);
requestAnimationFrame(turn);
});
await refresh();
typeset() cancela la composición en curso antes de pedir la siguiente. La promesa de la composición cancelada se rechaza en el acto con un AbortError, que typeset() convierte en null. En el worker, una composición que aún espera en la cola se descarta enseguida, y la que está en marcha se detiene al terminar su pasada de colocación, porque solo se comprueba la cancelación entre una pasada y la siguiente. refresh() numera sus composiciones y solo pinta la última, así que una composición del worker que llega tarde no puede pintar encima de una del hilo principal. El documento vuelve al hilo principal, donde renderPageToCanvas() lo pinta con las imágenes registradas allí. Al worker solo le hace falta el tamaño de cada imagen, que va en el recurso (1100 × 840). Cada bloque guarda su posición en el Markdown (sourceStart), y follow() muestra la última página con un bloque que empieza en el cursor o antes.
#4 · Una portada que es un estilo de título
// # The Time Machine {style="title"}: numbered false, so the Introduction is still chapter I.
const PLATE = TRIM.width * (840 / 1100); // mm: the plate's depth at full width (84 mm)
const DIAL = { x: 20, y: 7, size: 70 }; // mm: the dial's photograph, centred on the plate
const titlePage = {
id: 'title', numbered: false,
span: 'page', // the author's name stands below the column's foot, which would cut it
header: { elements: [] }, footer: { elements: [] }, // no running head, no folio
advancedDesign: { enabled: true, slot: { elements: [
{ kind: 'image', id: 'plate', resourceId: 'plate',
placement: { anchor: { to: 'bleed', edge: 'top-left' }, size: { width: 'fill' } } },
{ kind: 'image', id: 'dial', resourceId: 'dial', placement: { anchor: { to: 'bleed',
edge: 'top-left' }, offset: { x: mm(DIAL.x), y: mm(DIAL.y) },
size: { width: mm(DIAL.size), height: mm(DIAL.size) } } },
text('title', '{titleText}', DISPLAY, 28, { fontWeight: 700, lineHeight: 1.04,
overflow: 'wrap' }, // the title takes two lines
onPage(PLATE + 11)),
text('subtitle', '{subtitle}', TEXT, 12, { italic: true, color: col('oxblood') },
onPage(PLATE + 34.5)),
brassRule('rule', onPage(PLATE + 43), 12),
text('author', '{author}', LABEL, 10, { fontWeight: 500, letterSpacing: pt(2) },
onPage(PLATE + 46.5)),
] } },
};
La línea # The Time Machine {style="title"} compone la página 1 con el estilo de encabezado title, cuyos header y footer vacíos la dejan sin cabeceras ni folio. numbered: false deja el título fuera de la cuenta de capítulos, así que Introduction sigue siendo el capítulo I. La lámina se ancla a la esquina superior izquierda del sangrado, y el nombre del autor queda por debajo del pie de la columna. Un diseño que se queda en su columna se corta en el pie de la columna, así que el estilo lleva span: 'page'; sin esa opción, el nombre del autor no se pinta.
#5 · Cabeceras según el tipo de página
// pages: 'body' keeps the heads off the title page and the opener; parity puts the book's
// title on the verso and the chapter on the recto, folios on the outer edge.
const HEAD_Y = 8.2; // mm from the top edge to the top of the running heads
const SHIFT = (INNER - OUTER) / 2; // mm: the text block's centre is off the page's centre
const head = (id, content, parity, edge, x, style) => ({ kind: 'text', id, content, parity,
pages: 'body', fontSize: pt(8), color: col('oxblood'), ...style,
placement: { anchor: { to: 'page', edge }, offset: { x: mm(x), y: mm(HEAD_Y) } } });
const smallCaps = { fontFamily: LABEL, fontWeight: 500, letterSpacing: pt(1.2) };
const folio = { fontFamily: TEXT, color: col('ink') }; // the heads' size: the same baseline
const header = { elements: [
head('verso-folio', '{pageNumber}', 'even', 'top-left', OUTER, folio),
head('verso-title', '{title}', 'even', 'top', -SHIFT, smallCaps),
head('recto-chapter', '{chapterTitle}', 'odd', 'top', SHIFT, smallCaps),
head('recto-folio', '{pageNumber}', 'odd', 'top-right', -OUTER, folio),
] };
const footer = { elements: [{ ...text('drop-folio', '{pageNumber}', TEXT, 8,
{ color: col('muted') }, inColumn(6.5)), pages: 'opener' }] };
pages: 'body' deja sin cabeceras la portada y la apertura, y parity pone el título del libro en las páginas pares y el del capítulo en las impares, con los folios en el margen exterior. La apertura lleva en cambio un folio al pie, un elemento del footer con pages: 'opener'. Folios y cabeceras van en cuerpo 8 y a 8,2 mm del borde superior, así que las cifras del folio se apoyan en la misma línea base que la cabecera.
#6 · La apertura del capítulo
const chapter = { level: 1, numberingTemplate: '{1:I}', // {number} prints 'I'
breakBefore: { enabled: true, parity: 'any' }, // the next page, on either side
marginTop: pt(0), marginBottom: pt(0),
advancedDesign: { enabled: true, minHeight: line(8), slot: { elements: [
text('numeral', '{number}', DISPLAY, 24, { fontWeight: 700, color: col('oxblood') },
inColumn(5)),
brassRule('rule', inColumn(18.5), 10),
text('chapter', '{titleText}', DISPLAY, 12, { fontWeight: 700, letterSpacing: pt(1.8),
textTransform: 'uppercase', overflow: 'wrap' }, inColumn(22.5)), // a longer title wraps
] } } };
const colophon = { id: 'colophon', fontSize: pt(7.5), lineHeight: pt(10.5), color: col('muted'),
textAlign: 'center', firstLineIndent: pt(0) };
El {number} del diseño imprime el número del capítulo con la forma que le da numberingTemplate: '{1:I}', una I romana. minHeight reserva al menos ocho líneas, así que el texto empieza en la novena mientras el título ocupe una o dos, y más abajo si un título más largo necesita más sitio. breakBefore con parity: 'any' deja que el capítulo abra en la página 2, frente a su segunda página; el valor por defecto lo llevaría a la 3, una página impar.
La receta completa
// ═══ Postext Cookbook · Nº 056 · Live editor with layout in a Web Worker ═══════════
// https://postext.dev/en/cookbook/web-worker-live-editor
// Code: MIT · Text: H. G. Wells, The Time Machine, 1895 (PD, Gutenberg #35) · Dial: generated
// Fonts: Baskervville, Baskervville SC, Cinzel (SIL OFL 1.1) · Needs postext ≥ 1.25.0
import {
buildDocument, createMeasurementCache, renderPageToCanvas, registerResourceImage,
} from 'https://esm.sh/postext';
import { createLayoutWorker } from 'https://esm.sh/postext/worker';
const LANG = 'en'; // @lang: the language of the sample document (this recipe is English only)
const RECIPE = 'web-worker-live-editor';
// ─── 1 · Design ─────────────────────────────────────────────────────────────
const palette = { // every colour in the config links to one of these
ink: '#231f1a', // the text: a warm near-black
oxblood: '#7a1f1f', // the accent: running heads, the numeral, the subtitle, the plate's cloth
brass: '#a88a4a', // rules (never text: 2.7:1 on the paper)
gilt: '#d8bd7c', // the plate's frame, on the oxblood
muted: '#6b5d4b', // the drop folio and the colophon (5.3:1 on the paper)
paper: '#f2ead8', // a cream pocket-book paper
};
// Each colour names its palette entry and carries its hex.
const col = (id) => ({ hex: palette[id], model: 'hex', paletteId: id });
const colorPalette = [
...Object.entries(palette).map(([id, hex]) => ({ id, name: id, value: { hex, model: 'hex' } })),
// The engine's defaults link to 'main-color'. The editor takes any Markdown, and without this
// entry a list typed into it gets the default blue markers.
{ id: 'main-color', name: 'oxblood (defaults)', value: { hex: palette.oxblood, model: 'hex' } },
];
const [TEXT, LABEL, DISPLAY] = ['Baskervville', 'Baskervville SC', 'Cinzel'];
// The page: 110 × 147 mm, a text block of 25 whole lines.
const TRIM = { width: 110, height: 147 }; // mm: a Victorian pocket size, close to A6
const [BODY, LEAD, LINES] = [9.5, 13, 25]; // pt, pt, lines: the text block is LINES leads deep
const [TOP, INNER, OUTER] = [15, 11, 9]; // mm; mirrored, so INNER is the spine side
const MM_PER_PT = 25.4 / 72;
const MEASURE = TRIM.width - INNER - OUTER; // 90 mm: about 60 characters of Baskervville
const line = (n) => pt(n * LEAD); // n grid lines
const page = {
sizePreset: 'custom', width: mm(TRIM.width), height: mm(TRIM.height), dpi: 150,
backgroundColor: col('paper'),
margins: { top: mm(TOP), bottom: mm(TRIM.height - TOP - LINES * LEAD * MM_PER_PT),
left: mm(INNER), right: mm(OUTER), mirror: true },
};
const onPage = (y) => ({ anchor: { to: 'page', edge: 'top' }, offset: { y: mm(y) } }); // centred
const inColumn = (y) => ({ anchor: { to: 'container', edge: 'top' }, offset: { y: mm(y) } });
const text = (id, content, fontFamily, fontSize, style, placement) => ({ kind: 'text', id,
/* The editor: the Markdown on the left, the page it sets on the right, on a walnut desk. */
#editor {
--desk: #1c1814; --well: #120f0c; --text: #e4d9c1; --dim: #a39680; --brass: #c9a75e;
display: grid; grid-template-columns: minmax(0, 1fr) auto; grid-template-rows: auto 1fr auto;
gap: 0 30px; box-sizing: border-box; width: min(1152px, 100% - 32px); margin: 24px auto 0;
padding: 0 30px; background: var(--desk); border-radius: 14px;
box-shadow: 0 0 0 1px #2c261f, 0 30px 60px -30px rgb(0 0 0 / .9);
font: 500 12px/1.4 system-ui, sans-serif; color: var(--dim);
}
#editor > header, #editor > footer {
grid-column: 1 / -1; display: flex; align-items: center; gap: 12px; min-height: 58px;
letter-spacing: .12em; text-transform: uppercase;
}
#editor > header { justify-content: space-between; }
#editor select {
margin-left: 8px; padding: 5px 8px; border: 1px solid #3a3229; border-radius: 6px;
background: var(--well); color: var(--text); font: inherit; letter-spacing: .06em;
}
#source {
box-sizing: border-box; width: 100%; height: 100%; min-height: 360px; resize: none;
padding: 20px 22px; border: 0; border-radius: 8px; outline: 1px solid #2c261f;
background: var(--well); color: var(--text); caret-color: var(--brass);
font: 13.5px/1.7 ui-monospace, 'SF Mono', Menlo, Consolas, monospace;
scrollbar-width: thin; scrollbar-color: #3a3229 transparent;
}
#source:focus { outline-color: var(--brass); }
#source::selection { background: rgb(201 167 94 / .35); }
#editor figure { margin: 0; display: flex; flex-direction: column; align-items: center; }
/* The page at 110 × 147 mm, as tall as the desk allows. */
#proof {
display: block; height: min(700px, 100vh - 170px); aspect-ratio: 110 / 147; background: #f2ead8;
box-shadow: 0 1px 2px rgb(0 0 0 / .6), 0 24px 44px -18px rgb(0 0 0 / .9);
}
#editor figcaption { display: flex; align-items: center; gap: 14px; margin-top: 12px; }
#editor figcaption button {
width: 30px; height: 30px; border: 1px solid #3a3229; border-radius: 50%; padding: 0;
background: none; color: var(--text); font: 16px/1 system-ui, sans-serif; cursor: pointer;
}
#editor figcaption button:hover { border-color: var(--brass); color: var(--brass); }
#folio { min-width: 56px; text-align: center; font-variant-numeric: tabular-nums; }
#editor > footer { color: var(--text); font-variant-numeric: tabular-nums; }
/* The heartbeat: a hand the main thread turns every frame. */
#beat { width: 24px; height: 24px; flex: none; }
#beat circle { fill: none; stroke: var(--brass); stroke-width: 1.5; }
#beat path { stroke: var(--brass); stroke-width: 2; stroke-linecap: round; }
@media (max-width: 760px) {
#editor { grid-template-columns: 1fr; padding: 0 16px; gap: 0; }
#editor > header { flex-direction: column; align-items: flex-start; padding: 14px 0; }
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)
Errores frecuentes
Error frecuente
El worker de composición mide con sus propias fuentes
Un worker tiene su propio FontFaceSet, así que no ve las fuentes que ha cargado la página. Envíale los bytes de cada fuente con registerFonts() antes de la primera composición; el peso puede ser un texto ('400') o, desde postext 1.5, un número. Sin ellos el worker mide con una fuente de reserva y cambian los cortes de línea y el número de páginas; desde la 1.5 la consola lo avisa, una vez por cada familia que falta. Composición en un Web Worker →
Créditos
- Receta
- Ignacio Ferro
- Texto
- La máquina del tiempo, capítulo I · H. G. Wells · dominio público
- Imágenes
- El cuadrante de latón de la portada, una fotografía · Generated With Diffusion Models · original
- La tela burdeos y el marco dorado de la portada, dibujados en código con la paleta de la página · Ignacio Ferro · MIT
- Fuentes
- Baskervville (SIL OFL 1.1) · Baskervville SC (SIL OFL 1.1) · Cinzel (SIL OFL 1.1)
- Código
- MIT, como Postext
Editar este texto ↗ (se abre en una nueva pestaña)Carpeta de la receta en GitHub ↗ (se abre en una nueva pestaña)


