Saltar al contenido principal
Receta número 56

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

Editor en vivo con la composición en un Web Worker

Markdown junto a una página de bolsillo: un Web Worker compone con fuentes propias y cada pulsación cancela la composición en curso.

En esta página
  • Muestra en inglés: aún no hay edición en español
  • Formato 110 × 147 mm
  • 1 columna
  • Baskervville 9,5/13
  • Baskervville SC
  • Cinzel
  • 9 páginas
  • Nivel
  • Postext 1.57.1
  • Compuesto en 111 ms
  • 242 líneas de código

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

script.js · líneas 135–159en el código completo
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

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

script.js · líneas 309–321en el código completo
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

script.js · líneas 344–390en el código completo
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

script.js · líneas 55–77en el código completo
// # 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

script.js · líneas 81–97en el código completo
// 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

script.js · líneas 101–112en el código completo
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

Sandbox
// ═══ 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,

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

Texto
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)
Sandbox