Saltar al contenido principal
Receta número 35

Recetario · Capítulo 8 · Tablas

Almanaque del huerto: calendario y gráfico apaisado

Un gráfico de siembras apaisado en dos páginas, un calendario calculado con fechas y una matriz de cultivos asociados, coloreados con la paleta.

p. 27 · 1 de 4

  • Formato 210 × 280 mm
  • 2 columnas, medianil de 7 mm
  • Piazzolla 9,8/14
  • Commissioner
  • Gilda Display
  • 4 páginas
  • Nivel
  • Postext 1.57.1
  • Compuesto en 80 ms
  • 251 líneas de código

En pocas palabras

Las páginas de marzo de un almanaque de huerto, con un calendario del mes y tablas de colores. Enseña a crear tablas a partir de datos y a girar de lado una tabla demasiado ancha para la página.

Lo que vas a componer

Las páginas de marzo de un almanaque de huerto en italiano. La página 27 se abre con una acuarela de plantones en tierra oscura bajo un cielo pálido, «Marzo» a 84 pt y un refrán campesino. Bajo dos columnas de texto va el calendario del mes, que el pen calcula con las fechas: los domingos en rojo sobre una columna crema, el domingo y el lunes de Pascua sobre rosa y las fases de la luna junto a sus días. La página 28 reúne las tareas del mes en un recuadro de dos columnas y colorea de verde, rosa o crema una matriz de diez por diez de cultivos asociados, con el dibujo de cada cultivo en la diagonal. El gráfico de siembras, 38 cultivos por quincenas, no cabe a lo ancho y va girado en las páginas 29 y 30, con la cabecera repetida en la segunda.

Esta receta responde a

  • ¿Cómo compongo una tabla ancha apaisada en su propia página?
  • ¿Cómo hago una tabla con filas de cabecera, celdas combinadas, anchos de columna y alineación por celda?
  • ¿Cómo doy estilos distintos a varias tablas (rellenos, filas alternas, marcos redondeados) en un mismo documento?
  • ¿Cómo pongo imágenes o iconos dentro de las celdas de una tabla?
  • ¿Cómo añado muestras de color como leyenda en el texto, los pies o las notas de tabla?

La respuesta corta

script.js · líneas 31–67en el código completo
// The chart's `placement` (#region resources): a quarter turn makes it a page-span float on
// pages of its own, flush to the spine; rows past the page's width go on under a repeated head.
const chartPlacement = { rotate: 'ccw' }; // a float: 'here' ignores the turn
const MONTHS = ['gen', 'feb', 'mar', 'apr', 'mag', 'giu', 'lug', 'ago', 'set', 'ott', 'nov', 'dic'];
const SEASONS = [['INVERNO', 2], ['PRIMAVERA', 3], ['ESTATE', 3], ['AUTUNNO', 3], ['INVERNO', 1]];
const STATES = { S: 'ochre', C: 'green', T: 'brown' }; // seedbed, sown outdoors, planted out
const fortnight = (key) => MONTHS.indexOf(key.slice(0, 3)) * 2 + Number(key[3]); // 'mar2' → 6
function sowingChart(data) { // 'Pomodoro: S feb2–mar2, T apr2–mag2'; a bare line is a family
  const row = (first, isHeader = false) => [first, ...Array(24).fill('')]
    .map((content) => ({ content, isHeader }));
  let m = { headerRowCount: 2, columnWidths: [30, ...Array(24).fill(8.5)], // mm, as weights
    rows: [row('', true), row('', true)] };
  for (const line of data.trim().split('\n')) {
    const [name, plan] = line.split(': ');
    const r = m.rows.push(row(plan ? name : chip(name.toUpperCase(), 'famiglia'))) - 1;
    if (!plan) { m = mergeCells(m, span(r, 0, r, 24)); continue; } // a family heads its crops
    for (let f = 1; f <= 24; f++) { // every other month tinted, so a column reads down the page
      if ((f - 1) % 4 < 2) m = setCellBackground(m, at(r, f), col('cream'));
    }
    for (const step of plan.split(', ')) { // 'S feb2–mar2': one state over a run of fortnights
      const [state, range] = step.split(' ');
      const [from, to = from] = range.split('–').map(fortnight);
      for (let f = from; f <= to; f++) m = setCellBackground(m, at(r, f), col(STATES[state]));
    }
  }
  // Merged heads: 'Coltura' down both rows, each season over its months, each month over its
  // two fortnights. mergeCells marks the covered cells hiddenBy (gotcha: merged-cells-hiddenby).
  const merge = (r0, c0, r1, c1, content) => { // the head's text goes in its first cell
    m = mergeCells(setCellContent(m, at(r0, c0), content), span(r0, c0, r1, c1));
  };
  merge(0, 0, 1, 0, 'Coltura');
  let c = 1;
  for (const [name, n] of SEASONS) { merge(0, c, 0, c + 2 * n - 1, name); c += 2 * n; }
  MONTHS.forEach((month, i) => merge(1, 2 * i + 1, 1, 2 * i + 2, month.toUpperCase()));
  for (const r of [0, 1]) for (let f = 1; f <= 24; f++) m = setAlignment(m, at(r, f), 'center');
  return setCellBackground(m, at(1, fortnight('mar1')), col('red')); // this month's head
}

Ingredientes

Tipografía
Piazzolla, Gilda Display, Commissioner (SIL OFL 1.1)
Recursos
  • campo-1680.jpg
  • El campo de plantones de marzo de la apertura, una acuarela (Generated With Diffusion Models, original)
  • Las fases de la luna y los diez cultivos, dibujados en código con la paleta de la página (Ignacio Ferro, CC BY 4.0)

Elaboración

#1 · Gira el gráfico y deja que continúe

El código es la respuesta corta de arriba. Con rotate: 'ccw', la tabla pasa a ser un flotante a lo ancho de la página, en páginas propias (Colocación), con la cabecera hacia el borde izquierdo, y se pega al lomo tanto en la página impar como en la par. Girada, la tabla se compone a lo alto de la caja de texto y ocupa 227 de sus 237 mm: las 47 líneas enteras de 14 pt que caben en la rejilla, menos una para la separación del flotante. Sus filas se apilan a lo ancho de los 176 mm de la caja; cuando ya no caben, la tabla se corta entre dos filas y continúa en la página siguiente, bajo sus dos filas de cabecera y su pie, que termina en (segue) (Tablas más altas que la página). Solo un flotante puede girar: con position: 'here' el giro se ignora, y la tabla se partiría sin girar, entre filas, donde acaba su columna. La cabecera lleva tres clases de celdas combinadas: Coltura ocupa sus dos filas, cada estación abarca sus meses y cada mes, sus dos quincenas.

#2 · Un calendario calculado con fechas

script.js · líneas 71–110en el código completo
const [YEAR, MONTH, DAY] = [2027, 3, 24 * 60 * 60 * 1000]; // DAY in ms
const epochDay = (m, d) => Date.UTC(YEAR, m - 1, d) / DAY; // 1 January 1970 was a Thursday
const weekday = (d) => (epochDay(MONTH, d) + 3) % 7; // 0 is Monday: Italian weeks start there
function easter(y) { // the Gregorian computus (Meeus): [month, day]
  const a = y % 19, b = Math.floor(y / 100), c = y % 100, d = Math.floor(b / 4);
  const g = Math.floor((8 * b + 13) / 25), h = (19 * a + b - d - g + 15) % 30;
  const i = Math.floor(c / 4), k = c % 4, l = (32 + 2 * (b % 4) + 2 * i - h - k) % 7;
  const n = h + l - 7 * Math.floor((a + 11 * h + 22 * l) / 451) + 114;
  return [Math.floor(n / 31), (n % 31) + 1];
}
// The moon's age: mean synodic months since the new moon of 6 January 2000 at 18.14 UT.
const [SYNODIC, NEW_MOON] = [29.530588853, Date.UTC(2000, 0, 6, 18, 14) / DAY];
const quarter = (day) => Math.floor((((day - NEW_MOON) % SYNODIC) / SYNODIC) * 4); // 0–3
const PHASES = ['luna-nuova', 'primo-quarto', 'luna-piena', 'ultimo-quarto'];
const JOINER = '\u2060'; // a word joiner: the second line of a day without a note
const DAYS = ['LUNEDÌ', 'MARTEDÌ', 'MERCOLEDÌ', 'GIOVEDÌ', 'VENERDÌ', 'SABATO', 'DOMENICA'];
function calendarTable() { // the grid, and the quarters it draws, listed for the caption
  const e = epochDay(...easter(YEAR)) - epochDay(MONTH, 0); // Easter as a day of MONTH: 28 in 2027
  const feasts = { [e - 7]: 'Le Palme', [e]: 'Pasqua', [e + 1]: 'Pasquetta' };
  const notes = { 19: 'S. Giuseppe', 20: 'Equinozio' }; // March 2027's, typed by hand
  const first = weekday(1), days = epochDay(MONTH + 1, 1) - epochDay(MONTH, 1), moons = [];
  const week = (names, isHeader) => names.flatMap((content) => [content, '']) // a day: moon, date
    .map((content) => ({ content, isHeader }));
  let m = { headerRowCount: 1, columnWidths: Array(7).fill([7, 18]).flat(), rows: [week(DAYS, true),
    ...Array.from({ length: Math.ceil((first + days) / 7) }, () => week(Array(7).fill('')))] };
  for (let d = 1; d <= days; d++) {
    const r = 1 + Math.floor((first + d - 1) / 7), c = 2 * weekday(d), sunday = c === 12;
    // Sundays and feasts print in red. Every day has a second line, so all weeks are as tall.
    const note = feasts[d] ? chip(feasts[d], 'festa') : notes[d] ? chip(notes[d], 'nota') : JOINER;
    m = setCellContent(m, at(r, c + 1), `${sunday || feasts[d] ? chip(d, 'rosso') : d}\n${note}`);
    const fill = d === e || d === e + 1 ? 'blush' : sunday ? 'cream' : null;
    if (fill) for (const k of [c, c + 1]) m = setCellBackground(m, at(r, k), col(fill));
    const midnight = epochDay(MONTH, d) - 1 / 24, q = quarter(midnight + 1); // 00.00 CET
    if (q === quarter(midnight)) continue;
    m = setCellImage(m, at(r, c), { resourceId: PHASES[q] }); // a quarter begins today
    moons.push(`${PHASES[q].replace('-', ' ')} ${[1, 8, 11].includes(d) ? 'l’' : 'il '}${d}`);
  }
  for (let i = 0; i < 7; i++) m = mergeCells(m, span(0, 2 * i, 0, 2 * i + 1)); // one head a day
  return { model: setCellBackground(m, at(0, 12), col('red')), moons: moons.join(', ') };
}

Con Date.UTC, cada fecha se convierte en un número de día, y de ese número sale el día de la semana; la cuadrícula empieza el lunes 1 de marzo y ocupa cinco semanas. La Pascua sale del cómputo eclesiástico, y las fases de la luna, del mes sinódico medio. Con ese cálculo, una fase puede caer un día antes o después, como advierte el pie. El mismo bucle que dibuja cada luna escribe su fecha en el pie. La imagen de una celda siempre va encima de su texto; por eso cada día ocupa dos columnas, la de la luna y la de la fecha: una luna en la celda de la fecha bajaría la cifra solo en cuatro días. Los domingos y las fiestas salen en rojo con un estilo de chip que solo cambia el color, y las notas son chips a la mitad del cuerpo. Un día sin nota lleva como segunda línea un unidor de palabras (U+2060), y así las cinco semanas tienen la misma altura.

#3 · Colorea la matriz a partir de símbolos pegados

script.js · líneas 114–130en el código completo
const FILLS = { '+': 'leaf', '−': 'blush', '': 'cream' }; // good, bad, no known effect
function companionTable(tsv) {
  let m = { ...parseTSV(tsv, { headerRows: 1 }), columnWidths: [26, ...Array(10).fill(15)] };
  for (let r = 1; r < m.rows.length; r++) {
    m = setAlignment(m, at(r, 0), 'left', 'middle');
    for (let c = 1; c < m.rows[r].length; c++) {
      const symbol = m.rows[r][c].content; // + and − stay printed, for greyscale copies
      m = setCellContent(m, at(r, c), symbol && symbol !== '=' ? chip(symbol, 'segno') : '');
      m = symbol === '=' // the diagonal pairs a crop with itself: its picture instead
        ? setCellImage(m, at(r, c), { resourceId: `veg-${r}`, width: 0.62 })
        : setCellBackground(m, at(r, c), col(FILLS[symbol]));
      m = setAlignment(m, at(r, c), 'center', 'middle');
    }
  }
  for (let c = 1; c <= 10; c++) m = setAlignment(m, at(0, c), 'center');
  return m;
}

Las parejas se escriben como TSV, un símbolo por celda. parseTSV(tsv, { headerRows: 1 }) convierte la fila con los nombres de los cultivos en la cabecera. Los pesos de columnWidths reparten en milímetros los 176 mm de la medida: 26 para los nombres y 15 para cada cultivo. Cada símbolo corresponde a una entrada de la paleta, que setCellBackground pone de fondo en la celda; el + y el − se imprimen también, en un chip a 1,4 em, para que la matriz se lea en una copia en escala de grises. La diagonal empareja cada cultivo consigo mismo, y ahí setCellImage pone su dibujo, al 62 % del ancho interior de la celda.

#4 · Pon la leyenda con muestras de color

script.js · líneas 396–420en el código completo
const resourceTypes = [ // the almanac's own two: tables numbered through, a bare calendar
  { id: 'table', name: 'Tabella', shortLabel: 'Tab.', captionPrefix: 'Tabella',
    captionStyle: { position: 'above' } },
  { id: 'calendar', name: 'Calendario', shortLabel: 'Cal.', captionPrefix: '' }, // no label
].map((t) => ({ numberingTemplate: '{n}', resetOn: 'never', counterFormat: 'decimal', ...t }));
const table = (id, typeId, caption, model, styleId, extra) => ({ id, typeId, kind: 'table',
  caption, table: { model, styleId }, createdAt: 0, updatedAt: 0, ...extra });
const foot = { position: 'bottom', span: 'page' }; // across both columns, at the page's foot
const calendar = calendarTable(); // its key names the quarters the grid draws
const resources = [...pictures, // never cited: the opener and the cells draw them by id
  table('calendario', 'calendar', ':swatch{color="cream"} domeniche · :swatch{color="blush"} '
    + `Pasqua e Pasquetta · ${calendar.moons}, sul mese sinodico medio: un giorno prima o dopo `
    + 'è possibile. Per tradizione in crescente si semina ciò che fruttifica sopra terra, in '
    + 'calante le radici.', calendar.model, 'calendario', { placement: foot }),
  table('consociazioni', 'table', 'Consociazioni tra dieci ortaggi', companionTable(companions),
    'matrice', { placement: foot, note: ':swatch{color="leaf"} + favorevole · '
      + ':swatch{color="blush"} − da evitare · :swatch{color="cream"} nessun effetto noto. '
      + 'Indicazioni della tradizione orticola.' }),
  // Each part of a split table repeats its caption, so the key goes there; the note ends the last.
  table('semine', 'table', 'Semine al Nord e al Centro, in pianura e collina: '
    + ':swatch{color="ochre"} in semenzaio protetto · :swatch{color="green"} in piena terra · '
    + ':swatch{color="brown"} trapianto o messa a dimora', sowingChart(sowing), 'semine', {
    placement: chartPlacement, note: 'Al Sud e lungo le coste le date si anticipano di '
      + 'due-quattro settimane; in montagna si ritardano.' }),
];

:swatch{color="leaf"} compone un cuadrado de tres cuartos del cuerpo, relleno con una entrada de la paleta y perfilado en el color del texto; estas páginas lo usan en el texto corrido, en dos pies y en una nota. La leyenda del gráfico va en su pie, porque cada parte de una tabla partida repite el pie, mientras que la nota solo sale bajo la última. El calendario es un tipo de recurso propio con el prefijo del pie vacío, y su pie empieza por la leyenda y no por una etiqueta Tabella. position: 'bottom' con span: 'page' coloca el calendario y la matriz a lo ancho de las dos columnas, al pie de su página. La página 28 es la última con texto. En la última página de un capítulo, un flotante a lo ancho de la página sube hasta una línea por debajo del texto; por eso la matriz termina 10 mm por encima del margen inferior, y con layout.hugClosingFloats: false se quedaría al pie de la página.

#5 · Un estilo de la casa y una variante por tabla

script.js · líneas 134–145en el código completo
const tableStyle = { rules: 'horizontal', borderColor: col('rule'), borderWidth: pt(0.5),
  headerBackground: col('ink'), headerColor: col('paper'), headerFontFamily: LABEL,
  headerFontSize: pt(7), bodyFontSize: pt(8.5), cellPadding: mm(1.2),
  // An Italian document's split table says '(segue)' and 'Continua'; this spells the second out.
  continuesMarker: 'Continua alla pagina seguente' };
const tableStyles = [
  { id: 'calendario', bodyFontFamily: DISPLAY, bodyFontSize: pt(15), cellPadding: mm(1.4) },
  { id: 'matrice', rules: 'grid', borderColor: col('paper'), borderWidth: pt(2), // tiles
    headerBackgroundEnabled: false, headerColor: col('ink'), headerFontSize: pt(6.8) },
  { id: 'semine', rules: 'grid', borderColor: col('paper'), borderWidth: pt(1),
    bodyFontSize: pt(7.8), headerFontSize: pt(6.6), cellPadding: mm(1.1) },
];

tableStyle fija el estilo de la casa: cabecera con fondo de tinta y rótulos en Commissioner del color del papel, filetes finos entre filas y la línea que cierra cada parte de una tabla partida. Un documento en italiano cierra la parte con Continua y añade (segue) al pie de la parte siguiente; el almanaque escribe la primera entera, Continua alla pagina seguente. Cada estilo con nombre indica solo lo que cambia su tabla. El calendario compone los días en Gilda Display a 15 pt; la matriz quita el relleno de la cabecera, y la matriz y el gráfico trazan una rejilla de filetes del color del papel, de 2 pt y 1 pt, que corta sus rellenos en casillas.

#6 · El mes se abre con una acuarela

script.js · líneas 149–169en el código completo
const ART_H = 92, AIR = 5, BEARING = 1.5; // mm: painting, air under it, side bearing of the 84 pt M
const pin = (to, edge, x, y, size) => ({ anchor: { to, edge }, offset: { x: mm(x), y: mm(y) },
  ...(size && { size }) }); // to: 'page', or '#id' of an element listed before
const text = (id, content, family, size, color, placement, extra) => ({ kind: 'text', id,
  content, fontFamily: family, fontSize: pt(size), color: col(color), placement,
  align: placement.anchor.edge.endsWith('right') ? 'right' : 'left',
  overflow: 'wrap', ...extra }); // a long line takes a second one, in the heads too
const caps = (s) => ({ fontWeight: 600, textTransform: 'uppercase', letterSpacing: pt(s / 5) });
// minHeight: a floor under what the painting reserves, the first grid line AIR or more below it.
const OPENER_H = pt(LEAD * Math.ceil((ART_H + AIR - PAGE.top) / (LEAD * 25.4 / 72)));
const opener = { enabled: true, minHeight: OPENER_H, slot: { elements: [
  { kind: 'image', id: 'art', resourceId: 'campo',
    placement: pin('page', 'top-left', 0, 0, { width: mm(PAGE.w), height: mm(ART_H) }) },
  text('kicker', '{attr.kicker}', LABEL, 8.5, 'red', pin('page', 'top-left', PAGE.inner, 12),
    caps(8.5)), // page 1 is a recto: its inner margin is on the left
  text('title', '{titleText}', DISPLAY, 84, 'ink', pin('#kicker', 'below', -BEARING, 1),
    { lineHeight: 1 }), // a multiple of the size: set solid
  text('proverb', '{attr.proverb}', TEXT, 12.5, 'ink',
    pin('#title', 'below', BEARING, 1, { width: mm(140) }), { italic: true, lineHeight: 1.3 }),
  text('source', '{attr.source}', LABEL, 7, 'ink', pin('#proverb', 'below', 0, 1.6), caps(7)),
] } };

El encabezado de primer nivel se dibuja con una zona de diseño. La acuarela es un elemento de imagen en la cabeza de la página, y el antetítulo, el refrán y su fuente salen de los atributos del encabezado. La apertura reserva hasta el borde inferior de la acuarela, y minHeight es un mínimo algo más bajo: 92 mm de acuarela más 5 mm de aire, menos los 22 mm del margen superior, dan 75 mm, que se redondean hacia arriba a 16 líneas de 14 pt (79 mm). La primera línea de texto queda a 101 mm del borde superior de la página, 9 mm por debajo de la tierra. El título se desplaza 1,5 mm a la izquierda, lo que mide el blanco lateral de la M de Gilda Display a 84 pt, y así la gracia de la M se alinea con el antetítulo; el refrán se desplaza lo mismo hacia la derecha.

La receta completa

Sandbox
// ═══ Postext Cookbook · Nº 035 · Garden almanac: calendar grid and landscape chart ═════
// https://postext.dev/en/cookbook/garden-almanac
// Code: MIT · Text: original, Italian (CC BY 4.0) · Field: diffusion models · Icons: CC BY 4.0
// Fonts: Piazzolla, Gilda Display, Commissioner (SIL OFL 1.1) · Needs postext ≥ 1.57.0
import {
  buildDocumentWithFonts, prepareFonts, renderPageToCanvas, registerResourceImage, parseTSV,
  mergeCells, setCellContent, setCellBackground, setCellImage, setAlignment,
} from 'https://esm.sh/postext';

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

// ─── 1 · Design ─────────────────────────────────────────────────────────────
const palette = { ink: '#262a22', paper: '#fbf8ef', // a green-black on unbleached paper
  red: '#a2372a', // Sundays and feasts, as almanacs print them; kickers and labels
  green: '#5b8a32', ochre: '#d39a2e', brown: '#7a5230', // sown outdoors, in a seedbed, planted
  leaf: '#bfdaa2', blush: '#f3cdbd', cream: '#e9ddc1', // good pairs, bad pairs, neutral pairs
  sky: '#cfe2e6', rule: '#cfc6b2', muted: '#6b6e63' }; // sky and work box; hairlines; notes
// col() links a colour to its palette entry; the hex is the value the entry holds.
const col = (id) => ({ hex: palette[id], model: 'hex', paletteId: id });
const colorPalette = Object.entries({ ...palette, 'main-color': palette.red }) // the defaults' id
  .map(([id, hex]) => ({ id, name: id, value: { hex, model: 'hex' } }));
const [TEXT, DISPLAY, LABEL] = ['Piazzolla', 'Gilda Display', 'Commissioner'];
const PAGE = { w: 210, h: 280, top: 22, bottom: 21, inner: 18, outer: 16 }; // mm, mirrored
const LEAD = 14; // pt: the body's leading and baseline grid
const at = (row, column) => ({ row, col: column });
const span = (r0, c0, r1, c1) => ({ start: at(r0, c0), end: at(r1, c1) });
const chip = (text, style) => `:chip[${text}]{style="${style}"}`;

// #region answer: a crops × fortnights chart, turned to landscape on pages of its own
// The chart's `placement` (#region resources): a quarter turn makes it a page-span float on
// pages of its own, flush to the spine; rows past the page's width go on under a repeated head.
const chartPlacement = { rotate: 'ccw' }; // a float: 'here' ignores the turn
const MONTHS = ['gen', 'feb', 'mar', 'apr', 'mag', 'giu', 'lug', 'ago', 'set', 'ott', 'nov', 'dic'];
const SEASONS = [['INVERNO', 2], ['PRIMAVERA', 3], ['ESTATE', 3], ['AUTUNNO', 3], ['INVERNO', 1]];
const STATES = { S: 'ochre', C: 'green', T: 'brown' }; // seedbed, sown outdoors, planted out
const fortnight = (key) => MONTHS.indexOf(key.slice(0, 3)) * 2 + Number(key[3]); // 'mar2' → 6
function sowingChart(data) { // 'Pomodoro: S feb2–mar2, T apr2–mag2'; a bare line is a family
  const row = (first, isHeader = false) => [first, ...Array(24).fill('')]
    .map((content) => ({ content, isHeader }));
  let m = { headerRowCount: 2, columnWidths: [30, ...Array(24).fill(8.5)], // mm, as weights
    rows: [row('', true), row('', true)] };
  for (const line of data.trim().split('\n')) {
    const [name, plan] = line.split(': ');
    const r = m.rows.push(row(plan ? name : chip(name.toUpperCase(), 'famiglia'))) - 1;
    if (!plan) { m = mergeCells(m, span(r, 0, r, 24)); continue; } // a family heads its crops
    for (let f = 1; f <= 24; f++) { // every other month tinted, so a column reads down the page
      if ((f - 1) % 4 < 2) m = setCellBackground(m, at(r, f), col('cream'));

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

#Gira el gráfico en el sentido de las agujas del reloj

La cabecera mira entonces al borde derecho de la página, y el lector gira el libro hacia el otro lado.

-const chartPlacement = { rotate: 'ccw' }; // a float: 'here' ignores the turn
+const chartPlacement = { rotate: 'cw' }; // a float: 'here' ignores the turn

Errores frecuentes

Error frecuente

Las celdas combinadas necesitan hiddenBy: usa mergeCells

Las celdas se colocan según su posición en la fila, así que una celda combinada necesita celdas de relleno marcadas con hiddenBy donde se extiende; omitirlas, como en HTML, desplaza todas las columnas siguientes. Combina celdas con mergeCells. Desde postext 1.5 una tabla con una rejilla irregular se anota en doc.contentWarnings como raggedTableGrid, y parseTSV(texto, { headerRows }) marca las filas de cabecera. Tablas a partir de datos →

  • La imagen de una celda de tabla se dibuja siempre encima del texto de la celda y con su misma alineación. Para poner un icono junto a una cifra, dale al icono una columna propia, como hace el calendario con la luna.
  • La nota de una tabla partida solo aparece bajo la última parte; una leyenda que necesiten todas las partes va en el pie.

Créditos

Texto
  • El texto italiano de las páginas de marzo, con los pies y las notas de las tablas y el colofón, escrito para esta receta · Ignacio Ferro · CC BY 4.0
  • El refrán «Marzo asciutto, aprile bagnato, beato il villan che ha seminato», un dicho tradicional italiano · Proverbio contadino · dominio público
Imágenes
  • El campo de plantones de marzo de la apertura, una acuarela · Generated With Diffusion Models · original
  • Las fases de la luna y los diez cultivos, dibujados en código con la paleta de la página · Ignacio Ferro · CC BY 4.0
Fuentes
Piazzolla (SIL OFL 1.1) · Gilda Display (SIL OFL 1.1) · Commissioner (SIL OFL 1.1)
Sandbox