En pocas palabras
Un cuaderno de pasatiempos de verano para niños de 9 a 11 años, con crucigrama, sopa de letras y laberinto. Enseña a construir las cuadrículas a partir de simples líneas de letras.
Lo que vas a componer
Un cuaderno de verano para niños de 9 a 11 años: la cubierta, tres pasatiempos sobre el mar y una página de soluciones. Las páginas 2 a 5 se abren bajo un campo de color con el pie ondulado (azul mar, menta, coral y amarillo) y un título de 46 pt en Lilita One. El código compone el crucigrama y la sopa de letras como tablas a partir de líneas de letras, cada una con su estilo: casillas con filetes en el crucigrama, teselas claras con juntas blancas y esquinas redondeadas en la sopa. Las casillas negras y la palabra ya encontrada son rellenos de celda, y los números de las definiciones, superíndices en la esquina. El laberinto es un SVG generado con una semilla. La última página reúne las tres soluciones, sacadas de los mismos datos, sobre un recuadro que cuenta cómo anida la tortuga boba.
Esta receta responde a
- ¿Cómo doy estilos distintos a varias tablas (rellenos, filas alternas, marcos redondeados) en un mismo documento?
- ¿Cómo añado imágenes y tablas desde el código (recursos) en lugar de ![]() de Markdown?
- ¿Cómo escribo superíndices, subíndices y fórmulas químicas sin escribir LaTeX?
- ¿Cómo hago chips en línea: teclas, etiquetas, bancos de palabras para ejercicios?
- ¿Cómo pongo dos columnas dentro de un recuadro (una de texto junto a otra con una figura)?
La respuesta corta
// Every grid shares tableStyle; a named style sets its size, padding, rules and fills.
// A row is as tall as its lines plus the padding and a column is its share of the
// table's width, so the padding sets how deep a square is.
const CELL = (15 * LEAD) / 9; // pt: nine squares are fifteen lines of text, 9.4 mm each
const PAD = 1; // pt: a clue number sits this close to the corner, clear of the 1 pt rule
const CLUE_FACE = (CELL - 2 * PAD) / (2 * LEAD / BODY); // 8.9 pt: two lines fill a square
const LETTER = 15; // pt: the word search's capitals
const pad = (cell, face) => pt((cell - face * LEAD / BODY) / 2); // one line fills the cell
const KEY = 54; // mm: the three answers are this deep, so their captions share a line
const key = (count) => { // count squares in KEY mm, letters of 4/3 pt per mm of square
const side = (KEY / count) * PT_PER_MM, face = (KEY / count) * 4 / 3;
return { id: `solucion-${count}`, bodyFontSize: pt(face), cellPadding: pad(side, face),
borderWidth: pt(0.5) };
};
// No grid has a head row; the grey head is off for the Cookbook's default-skin check.
const tableStyle = { headerBackgroundEnabled: false, bodyFontFamily: LABEL };
const tableStyles = [
{ id: 'crucigrama', bodyFontSize: pt(CLUE_FACE), cellPadding: pt(PAD), borderWidth: pt(1) },
{ id: 'sopa', bodyFontSize: pt(LETTER), cellPadding: pad(CELL, LETTER), // same squares
bodyBackgroundEnabled: true, bodyBackground: col('tint'), // tiles with white joints
borderColor: col('paper'), borderWidth: pt(2.4), borderRadius: mm(4) },
key(9), key(12), // 6 mm squares with 8 pt letters, 4.5 mm squares with 6 pt letters
];
// A table resource names its style; a cell's own background covers the style's fill.
const here = (width) => ({ position: 'here', width, align: 'center' }); // of the column
const grid = (id, typeId, model, styleId, width, extra) => ({ id, typeId, kind: 'table',
createdAt: 0, updatedAt: 0, table: { model, styleId }, placement: here(width), ...extra });
Ingredientes
- Funciones
- Rellenos de celdaEstilo de tablasSuperíndices y subíndicesTablas a partir de datosEstilos de tabla con nombreChips en líneaColumnas en un recuadro o en el textoRecuadrosEstilos de títuloColores por parteAperturas diseñadasAtributos de títuloImágenes en los diseños de páginaCubiertas, portadas y colofonesCabeceras y foliosTipos de recurso propiosFiguras justo aquíEstilo de los piesFiguras y tablas como recursosPáginas en un canvas
- También usa
- Banda de capítulo a todo el anchoEstilos de párrafoCabeceras por secciónSaltos de línea en los títulos
- Tipografía
- Lexend, Lilita One, Chivo Mono (SIL OFL 1.1)
- Recursos
- Ninguno: todas las imágenes se dibujan en código
Elaboración
#1 · Un estilo de tabla, tres aspectos
El código es la respuesta corta de arriba. tableStyle pone todas las rejillas en Chivo Mono. Cada estilo con nombre de tableStyles fija su cuerpo, su relleno interior y sus filetes, y la tabla elige el suyo con table.styleId. El ancho de una columna es su parte del ancho de la tabla, pero una fila mide lo que sus líneas más el relleno interior, así que es el relleno el que fija la altura de cada casilla. La sopa de letras conserva la casilla de 9,41 mm del crucigrama alrededor de una línea de mayúsculas de 15 pt, y pad() calcula los 2,9 pt que deja esa línea por encima y por debajo. Sus filetes, de 2,4 pt y del color del papel, cortan el fondo claro en teselas, y borderRadius redondea las esquinas del marco a 4 mm y recorta los rellenos a su forma. En la página de soluciones, key() mete nueve o doce casillas en 54 mm: casillas de 6 mm con letras de 8 pt en el crucigrama y de 4,5 mm con letras de 6 pt en la sopa de letras. La solución del laberinto se dibuja en un cuadrado de 54 mm, así que las tres soluciones tienen la misma altura y sus pies comparten la línea de base, a 106,4 mm del borde superior.
#2 · Nueve casillas, quince líneas
// Two lines of CLUE_FACE (a number, an empty line) and the padding make a square.
function crossword(source, solved = false) {
const lines = source.trim().split('\n');
const white = (r, c) => (lines[r]?.[c] ?? '#') !== '#';
let clue = 0;
const rows = lines.map((line, r) => [...line].map((letter, c) => {
if (!white(r, c)) return { content: '', background: col('ink') }; // a black square
if (solved) return { content: letter, align: 'center' };
// A square is numbered when a word starts in it, across or down, in reading order.
const starts = (!white(r, c - 1) && white(r, c + 1)) || (!white(r - 1, c) && white(r + 1, c));
const number = starts ? `**^${++clue}^**` : JOINER; // a bold superscript, or nothing
return { content: `${number}\n${JOINER}` }; // an empty second line would add no depth
}));
return { rows, columnWidths: rows[0].map(() => 1) };
}
Cada casilla blanca lleva dos líneas de Chivo Mono de 8,9 pt (el número de la definición y una línea en blanco) dentro de 1 pt de relleno interior, 26,7 pt en total: 9,41 mm, un noveno del ancho de la tabla. Nueve casillas miden 84,7 mm, lo mismo que quince líneas de 16 pt del texto corrido, y el recuadro de las definiciones empieza en la rejilla base una línea más abajo. Una casilla lleva número, en orden de lectura, cuando en ella empieza una palabra horizontal o vertical. El número es un superíndice en negrita de 5,2 pt (el 58 % de 8,9 pt) subido 3 pt (un tercio de 8,9 pt), y eso lo coloca en la esquina superior de la casilla. La línea en blanco es un carácter de unión de palabras (U+2060). Una línea que se deja vacía no suma altura a la celda, y la rejilla se quedaría en 45,5 mm de alto. Una casilla negra es una celda vacía con background propio, vinculado a ink.
#3 · El código busca las palabras en la rejilla
const STEPS = [[0, 1], [1, 0], [1, 1], [-1, 1], [0, -1], [-1, 0], [-1, -1], [1, -1]];
function locate(letters, word) { // the squares of a word, in any of eight directions
const hits = [];
letters.forEach((line, r) => [...line].forEach((_, c) => STEPS.forEach(([dr, dc]) => {
const cells = [...word].map((_, i) => ({ row: r + i * dr, col: c + i * dc }));
if (cells.every(({ row, col: k }, i) => letters[row]?.[k] === word[i])) hits.push(cells);
})));
if (hits.length !== 1) throw new Error(`${word} is in the grid ${hits.length} times`);
return hits[0];
}
function wordSearch(source, fills) { // fills: [word, palette id] pairs
const letters = source.trim().split('\n').slice(-12);
let model = { rows: letters.map((line) => [...line].map((content) => ({ content,
align: 'center' }))) };
for (const [word, fill] of fills) {
for (const at of locate(letters, word)) model = setCellBackground(model, at, col(fill));
}
return model;
}
La rejilla son doce líneas de mayúsculas en su propio archivo de contenido, después de la lista de palabras que hay que buscar. locate() busca cada palabra en las ocho direcciones y lanza un error si no aparece exactamente una vez, así que una errata en la rejilla o en la lista detiene la composición antes de que se imprima una palabra que nadie podrá encontrar. setCellBackground devuelve un modelo de tabla nuevo con una casilla más rellena. El relleno va vinculado a una entrada de la paleta y tapa la tesela del estilo: coral para SOMBRILLA en la página 3, menta para las diez palabras en la página 5. La primera variante alterna el fondo de las filas desde el estilo de tabla (bodyAlternateBackground), y el relleno propio de una celda tapa esa franja. El banco de palabras de encima de la rejilla son dos filas centradas de chips: el de SOMBRILLA va relleno de coral, como sus casillas, y los otros nueve son blancos con borde azul marino.
#4 · Una apertura, cuatro colores
const BAND = 40; // mm: the colour field, from the top edge
const pin = (to, edge, x, y, size) => ({ anchor: { to, edge },
offset: { x: mm(x), y: mm(y) }, ...(size && { size }) });
const text = (id, content, family, size, placement, extra) => ({ kind: 'text', id, content,
fontFamily: family, fontSize: pt(size), color: col('ink'), overflow: 'wrap', placement,
align: placement.anchor.edge.endsWith('right') ? 'right' : 'left', ...extra });
const CAPS = { fontWeight: 700, textTransform: 'uppercase', letterSpacing: em(1 / 6) };
// The field's box sets the opener's depth: the text starts on the next grid line below.
const opener = { enabled: true, slot: { elements: [
{ kind: 'box', id: 'field', style: { backgroundColor: col('band') },
placement: pin('page', 'top-left', 0, 0, { width: 'fill', height: mm(BAND) }) },
{ kind: 'image', id: 'surf', resourceId: 'olas', // the field's foot, cut in waves
placement: pin('page', 'top-left', 0, BAND - 3, { width: mm(PAGE), height: mm(3.2) }) },
text('kicker', '{attr.kicker}', LABEL, 8.5, pin('page', 'top-left', MARGIN, 11), CAPS),
text('title', '{titleText}', DISPLAY, 46, pin('#kicker', 'below', -0.6, 0.5),
{ lineHeight: 1 }), // set solid
text('theme', '{attr.theme}', TEXT, 10, pin('page', 'top-right', -MARGIN, 23.5), {
fontWeight: 700, box: { backgroundColor: col('paper'), borderRadius: mm(3.5),
padding: { top: mm(1.6), right: mm(3.2), bottom: mm(1.6), left: mm(3.2) } } }),
] } };
// parity 'any': each puzzle opens the next page. span 'page' even in one column: a design kept
// in its column is cut at the column's foot, which would trim the cover's picture.
const puzzleLevel = { level: 1, span: 'page', breakBefore: { enabled: true, parity: 'any' },
advancedDesign: opener };
// '# Sopa de letras {style="sopa"}': the style's palette turns 'band' mint on that page,
// in the field, the folio disc and anything else linked to it.
const BANDS = { crucigrama: 'band', sopa: 'mint', laberinto: 'coral', soluciones: 'sun' };
const puzzleStyles = Object.entries(BANDS)
.map(([id, band]) => ({ id, palette: { band: palette[band] } }));
Las páginas de la 2 a la 5 comparten el mismo diseño. Un campo de color baja 40 mm desde el borde superior y termina en un pie ondulado dibujado en el color del papel; el antetítulo, el título y el tema, en su píldora blanca, salen de la línea del encabezado y de sus atributos. El campo y el disco del folio están vinculados a la entrada band de la paleta, y el estilo de encabezado de cada página le da su propio valor, de modo que # Sopa de letras {style="sopa"} los vuelve menta en la página 3. El nivel 1 lleva span: 'page' aunque el cuaderno tiene una sola columna: un diseño que se queda en su columna se corta en el pie de la columna, y el dibujo de la cubierta acabaría 16 mm antes del borde inferior. La caja del campo cuenta en la altura que reserva la apertura, así que el texto empieza en la siguiente línea de la rejilla base, a 44,2 mm del borde superior y 4 mm por debajo de las olas.
#5 · Las soluciones salen de los mismos datos
const resourceTypes = [ // a plain resource prints no caption; an answer is numbered
{ id: 'plain', name: 'Plain', shortLabel: '', captionPrefix: '' },
{ id: 'solucion', ...t({ en: { name: 'Solution', captionPrefix: 'Solution' },
es: { name: 'Solución', captionPrefix: 'Solución' } }), shortLabel: 'Sol.' },
].map((type) => ({ numberingTemplate: '{n}', resetOn: 'never', counterFormat: 'decimal',
...type }));
const ANSWER_GAP = 6; // mm between the three answers: gap=6mm on their :::columns fence
const ANSWER_WIDTH = KEY / ((MEASURE - 2 * ANSWER_GAP) / 3); // 54 mm of a 55.3 mm column
const answers = [
grid('sol-crucigrama', 'solucion', crossword(crosswordText, true), 'solucion-9', ANSWER_WIDTH,
{ caption: t({ en: 'Crossword', es: 'Crucigrama' }) }),
grid('sol-sopa', 'solucion', wordSearch(searchText, words.map((w) => [w, 'mint'])),
'solucion-12', ANSWER_WIDTH, { caption: t({ en: 'Word search', es: 'Sopa de letras' }) }),
picture('sol-laberinto', 'solucion', { placement: here(ANSWER_WIDTH), caption: t({
en: 'Maze', es: 'Laberinto' }), altText: t({ en: 'The maze and its way out to the sea',
es: 'El laberinto y su salida al mar' }) }),
];
La página de soluciones vuelve a llamar a crossword() con solved y a wordSearch() con las diez palabras, sobre los mismos archivos de contenido que los pasatiempos, así que si cambias una rejilla cambia también su solución. Los pasatiempos y los dibujos son del tipo Plain, cuyo captionPrefix vacío no imprime pie en un recurso sin texto de pie. Las soluciones son del tipo Solución, numeradas del 1 al 3 en orden de lectura para que coincidan con los antetítulos, de Pasatiempo 1 a Pasatiempo 3. Van en un grupo :::columns{count=3 breaks="2,3" gap=6mm} en el texto, sin recuadro alrededor (postext 1.25): breaks abre una columna nueva en la segunda y en la tercera solución, y gap separa las columnas 6 mm; cada solución mide 54 mm de ancho en una columna de 55,3 mm. El recuadro ¿Sabías que…? contiene un grupo propio, con breaks="2", para poner el dibujo del nido junto a su párrafo.
La receta completa
// ═══ Postext Cookbook · Nº 069 · Puzzle book: crossword, word search and maze ═══════
// https://postext.dev/en/cookbook/puzzle-book
// Code: MIT · Text and puzzles: original (CC BY 4.0) · Drawings: generated in code (CC BY 4.0)
// Fonts: Lexend, Lilita One, Chivo Mono (SIL OFL 1.1) · Needs postext ≥ 1.25.0
import {
buildDocumentWithFonts, prepareFonts, renderPageToCanvas, registerResourceImage,
setCellBackground,
} from 'https://esm.sh/postext';
const LANG = 'es'; // @lang: the language of the sample document ('en' | 'es')
const RECIPE = 'puzzle-book';
// ─── 1 · Design ─────────────────────────────────────────────────────────────
const palette = {
ink: '#1f2a44', // text, grid rules and the black squares: a navy near-black
paper: '#ffffff',
band: '#2d9cdb', // a puzzle's colour field: sea blue until a puzzle's style replaces it
sun: '#ffb627', coral: '#ff6f59', mint: '#5cc8a8', // the other fields; coral marks a find
tint: '#fff1cc', // boxes and word-search tiles
muted: '#5b6477', // running titles and the colophon
};
// Every colour is linked to its palette entry by id: a puzzle's palette recolours 'band'.
const col = (id) => ({ hex: palette[id], model: 'hex', paletteId: id });
const colorPalette = Object.entries({ ...palette, 'main-color': palette.ink })
.map(([id, hex]) => ({ id, name: id, value: { hex, model: 'hex' } }));
const [TEXT, DISPLAY, LABEL] = ['Lexend', 'Lilita One', 'Chivo Mono'];
const PAGE = 210, MARGIN = 16; // mm: a square booklet, the same margin on every side
const MEASURE = PAGE - 2 * MARGIN; // 178 mm
const BODY = 11.5, LEAD = 16; // pt: large, open text for young readers
const PT_PER_MM = 72 / 25.4;
const JOINER = '\u2060'; // a word joiner: a line with nothing on it that still counts
// #region answer: a named table style for each grid, picked by the table's styleId
// Every grid shares tableStyle; a named style sets its size, padding, rules and fills.
// A row is as tall as its lines plus the padding and a column is its share of the
// table's width, so the padding sets how deep a square is.
const CELL = (15 * LEAD) / 9; // pt: nine squares are fifteen lines of text, 9.4 mm each
const PAD = 1; // pt: a clue number sits this close to the corner, clear of the 1 pt rule
const CLUE_FACE = (CELL - 2 * PAD) / (2 * LEAD / BODY); // 8.9 pt: two lines fill a square
const LETTER = 15; // pt: the word search's capitals
const pad = (cell, face) => pt((cell - face * LEAD / BODY) / 2); // one line fills the cell
const KEY = 54; // mm: the three answers are this deep, so their captions share a line
const key = (count) => { // count squares in KEY mm, letters of 4/3 pt per mm of square
const side = (KEY / count) * PT_PER_MM, face = (KEY / count) * 4 / 3;
return { id: `solucion-${count}`, bodyFontSize: pt(face), cellPadding: pad(side, face),
borderWidth: pt(0.5) };
};
// No grid has a head row; the grey head is off for the Cookbook's default-skin check.
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
#Alterna el fondo de las filas de la sopa de letras
Un amarillo más intenso en una fila sí y otra no ayuda a un lector pequeño a seguir la fila. El relleno propio de una celda tapa la franja, así que SOMBRILLA sigue en coral; la solución tiene su propio estilo y no lleva franjas.
bodyBackgroundEnabled: true, bodyBackground: col('tint'), // tiles with white joints
+ bodyAlternateBackgroundEnabled: true, // a shade deeper than the tiles on every other row
+ bodyAlternateBackground: { hex: '#ffdd80', model: 'hex' },
borderColor: col('paper'), borderWidth: pt(2.4), borderRadius: mm(4) },#Dibuja un laberinto más difícil
Con 21 por 11 casillas en el mismo ancho, cada una mide 8,4 mm, y la solución de la página 5 se dibuja a partir del nuevo laberinto.
-const theMaze = maze(17, 9, 2027);
+const theMaze = maze(21, 11, 2027);Errores frecuentes
- Los números de las definiciones del recuadro se escriben a mano en el archivo de contenido, y los de la rejilla se calculan. Después de cambiar una rejilla, repasa las definiciones con ella, porque el código no las compara.
- La paleta de un estilo de encabezado cambia el color de los elementos de diseño, del texto y de los filetes y los rellenos de las tablas, pero no el del interior de un SVG, así que las olas del pie de cada campo se dibujan en el color del papel y un solo dibujo sirve para los cuatro campos.
Créditos
- Receta
- Ignacio Ferro
- Texto
- Texto original, CC BY 4.0
- Fuentes
- Lexend (SIL OFL 1.1) · Lilita One (SIL OFL 1.1) · Chivo 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)


