En pocas palabras
La hoja técnica de cuatro páginas de un sensor de temperatura. Enseña a crear tablas con datos de una hoja de cálculo, con encabezados compartidos y una tabla larga que sigue en otra página.
Lo que vas a componer
La hoja técnica del PX-7021, un sensor de temperatura de un fabricante imaginario, Pyxis Microdevices, ocupa cuatro páginas. Casi todo son tablas, con cabeceras llenas de celdas combinadas y un mapa de registros que no cabe en una columna. La portada empieza con una banda violeta que lleva la referencia y tres cifras clave. En la página 2, una sola tabla ocupa todo el ancho. Su cabecera de dos filas pone «Value» sobre «Min», «Typ» y «Max», los grupos de parámetros se combinan en la primera columna y un parámetro de cada dos va sobre fondo gris. El mapa de registros se corta al pie de la página 3 y sigue en la 4 con la cabecera repetida, junto a los códigos de pedido y encima del dibujo del encapsulado. Las tablas son datos de una hoja de cálculo pegados como TSV, porque Postext no interpreta las tablas de Markdown.
Esta receta responde a
- ¿Cómo hago una tabla con filas de cabecera, celdas combinadas, anchos de columna y alineación por celda?
- ¿Cómo parto una tabla larga entre páginas con la cabecera repetida y un aviso de «continúa»?
- ¿Cómo doy estilos distintos a varias tablas (rellenos, filas alternas, marcos redondeados) en un mismo documento?
- ¿Cómo mantengo los diagramas nítidos y con texto seleccionable en el PDF (SVG, másteres de impresión)?
- ¿Cómo añado imágenes y tablas desde el código (recursos) en lugar de ![]() de Markdown?
La respuesta corta
const at = (row, column) => ({ row, col: column });
const span = (r0, c0, r1, c1) => ({ start: at(r0, c0), end: at(r1, c1) });
const C = { group: 0, param: 1, symbol: 2, conditions: 3, min: 4, max: 6, unit: 7 }; // columns
function electricalTable(tsv) {
// headerRows marks the head, two rows here, which a split table would repeat on each part.
let m = Object.assign(parseTSV(tsv, { headerRows: 2 }), {
columnWidths: [22, 44, 16, 38, 15, 15, 15, 15] }); // weights: mm of the 180 mm measure
// 'Parameter' covers two columns and two rows; 'Value' spans Min, Typ and Max. mergeCells
// marks the covered cells hiddenBy, so no column shifts (gotcha: merged-cells-hiddenby).
for (const range of [span(0, C.group, 1, C.param), span(0, C.symbol, 1, C.symbol),
span(0, C.conditions, 1, C.conditions), span(0, C.min, 0, C.max),
span(0, C.unit, 1, C.unit)]) {
m = mergeCells(m, range); // 'Value' is centred over its three columns, the rest set left
m = setAlignment(m, range.start, range.start.col === C.min ? 'center' : 'left', 'middle');
}
// Min, Typ and Max go right, over their figures; setAlignment clears a vAlign it is not given.
for (let c = C.min; c <= C.max; c++) m = setAlignment(m, at(1, c), 'right');
let zebra = false;
for (let r = m.headerRowCount; r < m.rows.length; r++) {
const row = m.rows[r];
if (row[C.param].content) zebra = !zebra; // a parameter keeps one fill over its conditions
for (let c = 0; c < row.length; c++) {
// An empty cell continues the one above: a group, or a parameter and its symbol.
if (c <= C.symbol && row[c].content) {
let end = r;
while (m.rows[end + 1] && !m.rows[end + 1][c].content
&& (c === C.group || !m.rows[end + 1][C.param].content)) end++;
m = mergeCells(m, span(r, c, end, c));
}
// Figures flush right, as datasheets set them (no decimal tab: gap tab-stops).
m = setAlignment(m, at(r, c), c >= C.min && c <= C.max ? 'right' : 'left', 'middle');
// tableStyle.bodyAlternateBackground alternates row by row; this fill changes with the
// parameter, so it is set cell by cell. Each helper returns a new model, cheap at 20 rows.
if (c === C.group) m = setCellBackground(m, at(r, c), col('tint'));
else if (zebra) m = setCellBackground(m, at(r, c), col('zebra'));
}
}
return m;
}
Ingredientes
- Funciones
- Tablas a partir de datosTablas que pasan de páginaRellenos de celdaEstilos de tabla con nombreEstilo de tablasEstilo de los piesAtributos de títuloSuperíndices y subíndicesChips en líneaFiguras y tablas como recursosColocación de figurasAperturas diseñadasBanda de capítulo a todo el anchoImágenes en los diseños de páginaCabeceras y foliosTítulos numeradosRecuadrosEstilos de cifrasExportación a PDF
- También usa
- Citas que colocan las figurasEstilos de títuloFigura y Tabla en tu idiomaSaltos de página y de columnaCabeceras según el tipo de páginaEstilos de párrafoFuentes incrustadas en el PDFTipos de recurso propios
- Tipografía
- Fira Sans, Fira Sans Condensed, Fira Mono (SIL OFL 1.1)
- Recursos
- Ninguno: todas las imágenes se dibujan en código
Elaboración
#1 · Pega los datos y luego da forma a la tabla
El código está en la respuesta corta, más arriba. parseTSV(tsv, { headerRows: 2 }) marca las dos filas de cabecera; si la tabla se partiera, las dos se repetirían en cada parte. Los pesos de columnWidths suman 180, el ancho de la caja de texto en milímetros, de modo que cada peso es el ancho real de su columna en la página. mergeCells conserva cada celda cubierta y la marca con hiddenBy, y así ninguna columna se desplaza. setAlignment trabaja celda a celda y borra la alineación vertical si no se la pasas; por eso casi todas las llamadas vuelven a poner 'middle'. El gris se alterna de parámetro en parámetro, así que las dos filas de «Accuracy» comparten fondo; alternando por filas, como hace bodyAlternateBackground en el estilo de tabla, la segunda quedaría en blanco.
#2 · Cada modelo pasa a ser un recurso
const svgResource = (id, caption, altText, [w, h], placement) => ({ id, typeId: 'figure',
kind: 'svg', caption, altText, placement, createdAt: 0, updatedAt: 0,
svg: { fileId: `${id}.svg`, width: w * SCALE, height: h * SCALE } }); // fitted to its slot
const table = (id, caption, model, { styleId, placement, note } = {}) => ({ id, typeId: 'table',
kind: 'table', caption, note, placement, table: { model, styleId }, createdAt: 0, updatedAt: 0 });
// A float takes the first free slot after its first :ref; the logo is never cited, only drawn.
const resources = [
svgResource('logo', '', 'Pyxis Microdevices', LOGO),
svgResource('pinout', 'Pin configuration, 8-pin DFN, top view.', 'The package from above: '
+ 'pins 1 to 4 down the left side, 5 to 8 up the right.', PINOUT),
svgResource('circuit', 'Typical application, bus address 48h.', 'The sensor with a 100 nF '
+ 'capacitor, address pins to ground, and SDA, SCL and ALERT pulled up to a host.', CIRCUIT),
svgResource('outline', 'Package outline and land pattern, 8-pin DFN, in mm.', 'Top, bottom '
+ 'and side views of the 2 × 2 mm body, and the land pattern with its two vias.', OUTLINE,
{ position: 'bottom', span: 'page' }), // a strip across the foot of a page
table('electrical', 'Electrical characteristics, *V*~DD~ = 1.6 V to 5.5 V and *T*~A~ = −40 °C '
+ 'to 125 °C unless noted', electricalTable(electrical), { styleId: 'electrical',
placement: { position: 'top', span: 'page' }, note: 'Typical values at 3.3 V and 25 °C. '
+ '^1^ Tested at 25 °C and 50 °C, the rest by characterization. ^2^ Characterized, not '
+ 'tested in production. ^3^ One conversion a second, bus idle.' }),
// No placement: these float to the first free slot after their reference and split there.
table('pins', 'Pin functions', groupedTable(pins, [9, 16, 10, 52]), { styleId: 'grouped',
note: 'Types: P power, G ground, I input, O open-drain output, I/O open-drain input and '
+ 'output.' }),
table('registers', 'Register map', groupedTable(registers, [9, 17, 11, 50]), {
styleId: 'grouped', note: 'Reset values apply at power-on and after a general-call reset.' }),
table('ordering', 'Order codes', Object.assign(parseTSV(ordering, { headerRows: 1 }), {
columnWidths: [23, 29, 18, 17] }), { styleId: 'ordering',
note: 'WLCSP-4: fixed address 48h, no ALERT output.' }),
];
Cada tabla y cada dibujo es un recurso con su pie, y las tablas añaden una nota y un estilo con nombre. Los pies y las notas admiten cursiva, subíndices y superíndices: la tabla eléctrica da sus condiciones de medida con *V*~DD~ en el pie, que en las tablas va encima, y numera sus notas con ^1^. Un flotante ocupa el primer hueco libre después de su primer :ref. La tabla 1 se cita en la página 1 y va arriba, a todo el ancho, así que abre la página 2. El dibujo del encapsulado va abajo, también a todo el ancho, y las demás tablas se quedan con la colocación por defecto, un flotante del ancho de una columna. Colocada here, una tabla se queda en el texto; si no cabe en lo que resta de su columna, también se parte entre filas.
#3 · Deja que una tabla larga se parta sola
function groupedTable(tsv, columnWidths) {
let m = Object.assign(parseTSV(tsv, { headerRows: 1 }), { columnWidths });
const codes = [0, 2]; // Pin and Type, Addr. and Reset: short codes, centred, in a bare chip
// A TSV cell holds no line break: the data writes \n, and a line opening with • is a list.
m.rows = m.rows.map((row, r) => row.map((cell, c) => ({ ...cell,
content: r > 0 && row[1].content && codes.includes(c) ? `:chip[${cell.content}]{style="code"}`
: cell.content.replaceAll('\\n', '\n') })));
for (let r = 0; r < m.rows.length; r++) {
const last = m.rows[r].length - 1;
if (r >= m.headerRowCount && !m.rows[r][1].content) { // a lone first cell heads a group
m = setCellBackground(mergeCells(m, span(r, 0, r, last)), at(r, 0), col('tint'));
} else for (const c of codes) m = setAlignment(m, at(r, c), 'center');
}
return m; // no split code: the engine cuts it between rows and repeats the head
}
La tabla de patillas y el mapa de registros salen de la misma función, groupedTable. Una fila que solo tiene texto en la primera celda se combina a todo el ancho y lleva el fondo lila de los títulos de grupo. Una celda de TSV no admite saltos de línea, así que los datos escriben \n y la función lo cambia por un salto de verdad; una línea que empieza por • se compone entonces como elemento de lista. Los códigos cortos van en el estilo de chip code, que no tiene fondo, borde ni relleno lateral y los compone en Fira Mono a 0,9 em. Si una tabla flotante no cabe en la columna vacía que se le ofrece, el motor la corta entre filas y pasa el resto al siguiente hueco libre, bajo la cabecera repetida y con (continued) detrás del pie. Debajo de la primera parte va el aviso de continuesMarker, «Continued on the next page», y la nota espera a la última (tablas más altas que la página).
#4 · Un estilo de la casa y una variante por tabla
tableStyle: { headerBackground: col('brand'), headerColor: col('paper'), headerFontFamily: COND,
headerFontSize: pt(8.5), bodyFontSize: pt(8), rules: 'horizontal', borderColor: col('rule'),
borderWidth: pt(0.5), cellPadding: mm(1.3) },
tableStyles: [ // a resource picks one with table.styleId
// White rules cut the fills apart and show where each merge and each group ends.
{ id: 'electrical', borderColor: col('paper'), borderWidth: pt(1.4), cellPadding: mm(1.1),
figureStyle: 'tabular' }, // Fira's tnum: the digits of Min, Typ and Max line up
// Written out although it is the default: 'clip' and 'hide' cut a table taller than the page.
{ id: 'grouped', overflow: 'split', continuedSuffix: '(continued)',
continuesMarker: 'Continued on the next page' },
// A compact list in the condensed face, boxed by a rounded outer frame.
{ id: 'ordering', headerBackground: col('tint'), headerColor: col('brand'),
rules: 'outer', borderRadius: mm(1.5), bodyFontFamily: COND },
],
captionStyle: { fontFamily: COND, fontSize: pt(9.5), labelColor: col('brand'), gap: mm(2),
note: { fontSize: pt(7.5), color: col('muted') } },
tableStyle recoge lo que comparten todas las tablas. Cada entrada de tableStyles fija solo lo que cambia en las suyas, y un recurso elige una con table.styleId. La tabla eléctrica cambia los filetes grises por filetes blancos de 1,4 pt, que separan los fondos y marcan dónde acaba cada celda combinada. La de pedidos lleva un marco exterior redondeado y la Fira Sans Condensed, para que sus cuatro columnas quepan en una columna de texto. El figureStyle: 'tabular' del estilo eléctrico pide a la Fira Sans el rasgo tnum, cifras de un mismo ancho, para que los dígitos de Min, Typ y Max se alineen en cada columna.
#5 · Rótulos que siguen siendo texto en el PDF
// label() writes each <text> with font-family="Fira Mono". loadSvg runs the markup through
// inlineSvgFonts, which embeds that face in the SVG, so the canvas draws the labels in it;
// the PDF sets them as real text in the Fira Mono it embeds.
await loadSvg('logo.svg', logo);
const drawings = { pinout: pinout(), circuit: circuit(), outline: outline() }; // by resource id
for (const [id, markup] of Object.entries(drawings)) await loadSvg(`${id}.svg`, markup);
Los rótulos de las patillas, del circuito y del encapsulado son elementos <text> que piden Fira Mono, la letra de rótulos del documento. Un SVG llega al canvas como imagen, así que el loadSvg del kit pasa antes el marcado por inlineSvgFonts, que incrusta en el SVG las fuentes que pide su texto; el canvas dibuja entonces los rótulos en Fira Mono. El PDF compone cada <text> como texto seleccionable con las fuentes que incrusta.
#6 · Apertura, cabecera y pie de página
const place = (to, edge, x, y, size) => ({ anchor: { to, edge }, offset: { x: mm(x), y: mm(y) },
...(size && { size }) });
const inset = (edge, y, size) => // a page corner, moved in by the side margin
place('page', edge, edge.endsWith('left') ? MARGIN.x : -MARGIN.x, y, size);
const text = (id, content, family, size, color, placement, extra) => ({ kind: 'text', id,
content, fontFamily: family, fontSize: pt(size), color: col(color), placement, ...extra });
const caps = (size, weight = 600) => ({ fontWeight: weight, letterSpacing: pt(size * 0.16),
textTransform: 'uppercase' });
const badge = { ...caps(7.5, 700), box: { backgroundColor: col('hazard'),
padding: { top: pt(1.6), bottom: pt(1.4), left: pt(4), right: pt(4) } } };
const mark = (size, edge, y) => ({ kind: 'image', id: 'mark', resourceId: 'logo', // by id
placement: inset(edge, y, { width: mm(size) }) });
const maker = (size, color, y) => text('maker', 'Pyxis Microdevices', COND, size, color,
place('#mark', 'right-of', size / 4, y), caps(size));
const keyFigure = (n, y) => [ // {attr.k1} over its label {attr.k1l}, flush right on the band
text(`k${n}`, `{attr.k${n}}`, COND, 22, 'paper', inset('top-right', y), { fontWeight: 600 }),
text(`k${n}l`, `{attr.k${n}l}`, COND, 7, 'tint', inset('top-right', y + 9), caps(7))];
const BAND = 84; // mm: the violet band across the head of page 1
// The band under the top margin and 9 mm or more of white, in whole grid lines (16 here).
const OPENER_LINES = Math.ceil((BAND - MARGIN.y + 9) / (LEAD * 25.4 / 72));
const opener = {
enabled: true, minHeight: pt(OPENER_LINES * LEAD), // so the columns under it start on the grid
slot: { elements: [
{ kind: 'box', id: 'band', style: { backgroundColor: col('brand') }, placement: {
anchor: { to: 'bleed', edge: 'top-left' }, size: { width: 'fill', height: mm(BAND) } } },
mark(6, 'top-left', 12), maker(8.5, 'paper', 1.7),
text('doc', 'Datasheet {subtitle} · {publishDate}', MONO, 7.5, 'tint',
inset('top-right', 13.6)),
text('kicker', '{attr.kicker}', COND, 9.5, 'tint', inset('top-left', 30), caps(9.5)),
text('title', '{titleText}', COND, 64, 'paper', place('#kicker', 'below', 0, 0.5),
{ fontWeight: 700, lineHeight: 1 }),
text('lead', '{attr.lead}', 'Fira Sans', 12, 'paper', place('#title', 'below', 0, 2.5,
{ width: mm(108) }), { lineHeight: 1.32, align: 'left' }), // wraps within its width
text('status', 'Preliminary', COND, 7.5, 'ink', place('#lead', 'below', 0, 4.5), badge),
...[1, 2, 3].flatMap((n) => keyFigure(n, 15 + 15 * n)),
] },
};
const header = { elements: [ // body pages only: the opener has its band
text('running-title', '{chapterTitle}', COND, 9, 'brand', inset('top-left', 10.4),
{ fontWeight: 700, pages: 'body' }),
text('flag', 'Preliminary', COND, 7.5, 'ink', inset('top-right', 10.2),
{ ...badge, pages: 'body' }),
{ kind: 'rule', id: 'hairline', pages: 'body', thickness: pt(0.5), color: col('rule'),
placement: inset('top-left', 15.5, { width: mm(TRIM[0] - 2 * MARGIN.x) }) },
] };
const footer = { elements: [ // every page: an image element works in a running slot too
mark(4.5, 'bottom-left', -9), maker(7, 'ink', 1.2),
text('folio', '{pageNumber}/{totalPages}', COND, 8, 'brand', inset('bottom-right', -9.6),
{ fontWeight: 700 }),
text('doc', '{subtitle} ·', MONO, 7, 'muted', place('#folio', 'left-of', -1.5, 0.4)),
] };
La referencia es el encabezado de primer nivel, y su apertura se dibuja con una zona de diseño: una caja violeta hasta el sangrado, el logotipo, y un antetítulo, una entradilla y tres cifras clave que salen de los atributos del encabezado. Un elemento de imagen sirve en la cabecera y en el pie de página igual que en una apertura, y el pie empieza con uno que apunta al recurso del logotipo. Los elementos de la cabecera llevan pages: 'body', así que ninguno aparece en la portada.
La receta completa
// ═══ Postext Cookbook · Nº 010 · Datasheet: tables from data, merged headers ════════
// https://postext.dev/en/cookbook/technical-datasheet
// Code: MIT · Text: original (CC BY 4.0) · Drawings: generated in code (CC BY 4.0)
// Fonts: Fira Sans, Fira Sans Condensed, Fira Mono (SIL OFL 1.1) · Needs postext ≥ 1.65.0
// The datasheet of a fictional sensor. Postext reads no pipe tables, so the tables are data:
// TSV pasted from a spreadsheet, parsed into table models, then merged, aligned and filled.
import {
buildDocumentWithFonts, prepareFonts, renderPageToCanvas, registerResourceImage,
defaultResourceTypes, parseTSV, mergeCells, setAlignment, setCellBackground, inlineSvgFonts,
} from 'https://esm.sh/postext';
import { renderToPdf, decompressWoff2 } from 'https://esm.sh/postext-pdf';
const LANG = 'en'; // @lang: the language of the sample document ('en' | 'es')
const RECIPE = 'technical-datasheet';
// ─── 1 · Design ─────────────────────────────────────────────────────────────
const palette = { // eight named colours; every colour in the config links to one of them
ink: '#16181d', brand: '#5a2a8a', // text; Pyxis violet: the band, table heads, numbers
tint: '#eee6f5', zebra: '#f3f4f6', // violet wash for groups and pins; every other row
hazard: '#f2b705', rule: '#c9ccd3', // maximum ratings and the badge; hairlines
muted: '#5d636d', paper: '#ffffff', // running heads, notes and units; white
};
// Every colour carries its paletteId: change a value in `palette` and all its uses follow.
const col = (id) => ({ hex: palette[id], model: 'hex', paletteId: id });
const colorPalette = [ // the defaults link to 'main-color', so it is set to the brand violet
...Object.entries(palette).map(([id, hex]) => ({ id, name: id, value: { hex, model: 'hex' } })),
{ id: 'main-color', name: 'brand (defaults)', value: { hex: palette.brand, model: 'hex' } },
];
// #region answer: pasted TSV becomes a table: two header rows, merged cells, zebra fills
const at = (row, column) => ({ row, col: column });
const span = (r0, c0, r1, c1) => ({ start: at(r0, c0), end: at(r1, c1) });
const C = { group: 0, param: 1, symbol: 2, conditions: 3, min: 4, max: 6, unit: 7 }; // columns
function electricalTable(tsv) {
// headerRows marks the head, two rows here, which a split table would repeat on each part.
let m = Object.assign(parseTSV(tsv, { headerRows: 2 }), {
columnWidths: [22, 44, 16, 38, 15, 15, 15, 15] }); // weights: mm of the 180 mm measure
// 'Parameter' covers two columns and two rows; 'Value' spans Min, Typ and Max. mergeCells
// marks the covered cells hiddenBy, so no column shifts (gotcha: merged-cells-hiddenby).
for (const range of [span(0, C.group, 1, C.param), span(0, C.symbol, 1, C.symbol),
span(0, C.conditions, 1, C.conditions), span(0, C.min, 0, C.max),
span(0, C.unit, 1, C.unit)]) {
m = mergeCells(m, range); // 'Value' is centred over its three columns, the rest set left
m = setAlignment(m, range.start, range.start.col === C.min ? 'center' : 'left', 'middle');
}
// Min, Typ and Max go right, over their figures; setAlignment clears a vAlign it is not given.
for (let c = C.min; c <= C.max; c++) m = setAlignment(m, at(1, c), 'right');
let zebra = false;
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
#Separa todas las filas con filetes grises
Con filetes de medio punto en el gris rule de la paleta, todas las filas quedan separadas, tengan fondo o no; los blancos desaparecen donde se tocan dos filas sin fondo.
- { id: 'electrical', borderColor: col('paper'), borderWidth: pt(1.4), cellPadding: mm(1.1),
+ { id: 'electrical', borderColor: col('rule'), borderWidth: pt(0.5), cellPadding: mm(1.1),#Pon los pies de tabla sobre una barra
El estilo de pie del tipo tabla puede pintar una barra detrás del pie; aquí es del color del texto (ink), con el pie en blanco y la etiqueta en el amarillo de advertencia.
- ...(type.id === 'table' && { captionStyle: { position: 'above' } }) })),
+ ...(type.id === 'table' && { captionStyle: { position: 'above', backgroundEnabled: true,
+ background: col('ink'), color: col('paper'), labelColor: col('hazard') } }) })),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 →
- La primera parte de una tabla partida deja el pie de su columna al texto cuando caben debajo tres líneas o más, y siempre lo hace en una columna que ya tiene un flotante. Haz que una tabla larga empiece en una columna sin otros flotantes, como el mapa de registros, y ajusta sus filas para que la primera parte llegue al pie de la columna.
- Los elementos de texto de diseño van centrados por defecto. La entradilla tiene un ancho fijo, así que necesita
align: 'left'para alinearse bajo la referencia. - En la última página de un capítulo, Postext sube los flotantes a todo el ancho que van bajo el texto y los deja a una línea de distancia, de modo que una figura
bottomqueda justo debajo de la última línea y no al pie de la página. La página 4 está redactada para llenar sus columnas, y el dibujo del encapsulado mide 48,3 mm de alto para que el texto de encima acabe en una línea de la rejilla base. Así al dibujo no le queda sitio para subir y acaba a la misma altura que el pie de las demás páginas. Conlayout.hugClosingFloats: falseno los sube.
Créditos
- Receta
- Ignacio Ferro
- Texto
- Texto original, CC BY 4.0
- Fuentes
- Fira Sans (SIL OFL 1.1) · Fira Sans Condensed (SIL OFL 1.1) · Fira Mono (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)


