Em poucas palavras
Um caderno de passatempos de férias para crianças de 9 a 11 anos, com palavras cruzadas, caça-palavras e labirinto. Mostra como montar as grades dos jogos a partir de simples linhas de letras.
O que você vai compor
Um caderno de férias para crianças de 9 a 11 anos: uma capa, três passatempos sobre o mar e uma página de respostas. As páginas 2 a 5 abrem sob um campo de cor com o pé ondulado (azul-mar, verde-menta, coral e, nas respostas, amarelo) e um título de 46 pt em Lilita One. O código monta as palavras cruzadas e o caça-palavras como tabelas a partir de linhas de letras e dá a cada um seu próprio estilo de tabela: casas com fios nas palavras cruzadas, ladrilhos claros com rejuntes brancos e cantos arredondados no caça-palavras. As casas pretas das palavras cruzadas e a palavra já encontrada no caça-palavras são fundos de célula, e os números das dicas são sobrescritos no canto. O labirinto é um SVG desenhado a partir de uma semente. A última página imprime as três respostas lado a lado a partir dos mesmos dados, acima de um box sobre como a tartaruga-cabeçuda faz o ninho.
Esta receita responde a
- Como dou estilos diferentes a várias tabelas (preenchimentos, células zebradas, molduras arredondadas) em um mesmo documento?
- Como adiciono imagens e tabelas a partir do código (recursos) em vez de usar ![]() do Markdown?
- Como escrevo sobrescritos, subscritos e fórmulas químicas sem recorrer à notação matemática completa?
- Como faço chips em linha: teclas, etiquetas, bancos de palavras para exercícios?
- Como coloco duas colunas dentro de um boxe (uma coluna de texto ao lado de uma coluna com figura)?
A resposta curta
// 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
- Funcionalidades
- Preenchimento de célulasEstilo de tabelaSobrescritos e subscritosTabelas a partir de dadosEstilos de tabela com nomeChips no textoColunas num boxe ou no textoBoxesEstilos de títuloCores por parteAberturas desenhadasAtributos de títuloImagens nos designs de páginaCapas, folhas de rosto e colofõesCabeços e fóliosTipos de recurso personalizadosFiguras exatamente aquiEstilo de legendaFiguras e tabelas como recursosPáginas em um canvas
- Também usa
- Faixa de capítulo em largura totalEstilos de parágrafoCabeços por seçãoQuebras de linha nos títulos
- Tipografia
- Lexend, Lilita One, Chivo Mono (SIL OFL 1.1)
- Materiais
- Nenhum: todas as imagens são desenhadas em código
Preparo
#1 · Um estilo de tabela, três visuais
O código é a resposta curta logo acima. tableStyle põe todas as grades em Chivo Mono. Cada estilo nomeado em tableStyles define o próprio corpo, o enchimento e os fios, e a tabela escolhe o seu com table.styleId. A largura de uma coluna é a parte da largura da tabela, mas a altura de uma linha é a das linhas de texto mais o enchimento, por isso é o enchimento que define a altura de cada casa. O caça-palavras mantém a casa de 9,41 mm das palavras cruzadas em volta de uma linha de maiúsculas de 15 pt, e pad() calcula os 2,9 pt que essa linha deixa acima e abaixo. Os fios dele, de 2,4 pt e na cor do papel, cortam o fundo claro em ladrilhos, e borderRadius arredonda os cantos da moldura em 4 mm e recorta os fundos nessa forma. Na página de respostas, key() encaixa nove ou doze casas em 54 mm: casas de 6 mm com letras de 8 pt nas palavras cruzadas, de 4,5 mm com letras de 6 pt no caça-palavras. A resposta do labirinto é desenhada num quadrado de 54 mm, e assim as três respostas têm a mesma altura e as legendas dividem a mesma linha de base, a 106,4 mm da borda superior.
#2 · Nove casas, quinze linhas
// 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) };
}
Uma casa branca leva duas linhas de Chivo Mono de 8,9 pt (o número da dica e uma linha vazia) dentro de 1 pt de enchimento, 26,7 pt no total: 9,41 mm, um nono da largura da tabela. Nove casas medem 84,7 mm de altura, o mesmo que quinze linhas de 16 pt do texto corrido, e o box das dicas começa na grade de linhas de base uma linha abaixo. Uma casa recebe número, em ordem de leitura, quando nela começa uma palavra horizontal ou vertical. O número é um sobrescrito em negrito de 5,2 pt (58 % de 8,9 pt) erguido 3 pt (um terço de 8,9 pt), o que o põe no canto superior da casa. A linha vazia é um word joiner (U+2060). Uma linha deixada vazia não soma altura à célula, e a grade sairia com 45,5 mm de altura. Uma casa preta é uma célula vazia com background próprio, ligado a ink.
#3 · O código encontra as palavras na grade
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;
}
A grade são doze linhas de maiúsculas num arquivo de conteúdo próprio, depois da lista de palavras a encontrar. locate() procura cada palavra nas oito direções e lança um erro se ela não aparecer exatamente uma vez, por isso um erro de digitação na grade ou na lista interrompe a composição antes que se imprima uma palavra que ninguém vai achar. setCellBackground devolve um novo modelo de tabela com mais uma casa preenchida. O fundo é ligado a uma entrada da paleta e cobre o ladrilho do estilo: coral para UMBRELLA na página 3, verde-menta para as dez palavras na página 5. A primeira variação alterna o fundo das linhas a partir do estilo de tabela (bodyAlternateBackground), e o fundo próprio de uma célula cobre a listra. O banco de palavras acima da grade são duas fileiras centralizadas de chips: o de UMBRELLA é preenchido de coral como as casas, e os outros nove são brancos com borda azul-marinho.
#4 · Uma abertura, quatro cores
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] } }));
As páginas 2 a 5 dividem um mesmo design. Um campo de cor desce 40 mm a partir da borda superior e termina num pé ondulado desenhado na cor do papel; o antetítulo, o título e o tema, na pílula branca, vêm da linha do título e dos atributos. O campo e o disco do fólio são ligados à entrada band da paleta, e o estilo de título de cada página dá a band um valor próprio, de modo que # Word Search {style="sopa"} deixa os dois em verde-menta na página 3. O nível 1 define span: 'page' embora o livro tenha uma só coluna: um design mantido na coluna é cortado no pé da coluna, e o desenho da capa terminaria 16 mm antes da borda inferior. A caixa do campo conta na altura que a abertura reserva, e o texto começa na linha seguinte da grade, a 44,2 mm da borda superior e 4 mm abaixo das ondas.
#5 · As respostas vêm dos mesmos dados
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' }) }),
];
A página de respostas chama crossword() com solved e wordSearch() com as dez palavras, sobre os mesmos arquivos de conteúdo dos passatempos, e assim uma alteração numa grade muda também a resposta. Os passatempos e os desenhos usam o tipo Plain, cujo captionPrefix vazio não imprime legenda para um recurso sem texto de legenda. As respostas usam o tipo Solution, numeradas de 1 a 3 em ordem de leitura para bater com os antetítulos, de Puzzle 1 a Puzzle 3. Elas ficam num grupo :::columns{count=3 breaks="2,3" gap=6mm} no texto, sem box em volta (postext 1.25): breaks abre uma nova coluna na segunda e na terceira resposta, e gap separa as colunas em 6 mm; cada resposta tem 54 mm de largura numa coluna de 55,3 mm. O box Did you know? contém um grupo próprio, com breaks="2", para pôr o desenho do ninho ao lado do parágrafo.
A receita 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 = 'en'; // @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.
O script.js montado funciona como está: cole-o como script de módulo em qualquer página ou abra a receita no CodePen. Pasta da receita no GitHub ↗ (abre em uma nova aba)
Variações
#Alterne o fundo das linhas do caça-palavras
Um amarelo mais forte numa linha sim, outra não ajuda um leitor pequeno a seguir uma linha de letras. O fundo próprio de uma célula cobre a listra, de modo que UMBRELLA continua coral; a grade de respostas tem estilo próprio e fica sem listras.
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) },#Desenhe um labirinto mais difícil
Vinte e uma por onze casas cabem na mesma largura com 8,4 mm cada, e a resposta da página 5 é desenhada a partir do novo labirinto.
-const theMaze = maze(17, 9, 2027);
+const theMaze = maze(21, 11, 2027);Erros comuns
- Os números das dicas no box são digitados no arquivo de conteúdo, enquanto os da grade são calculados. Depois de editar uma grade, confira as dicas com ela, porque o código não as compara.
- A paleta de um estilo de título recolore elementos de design, texto, fios e fundos de tabela, mas não o interior de um SVG; por isso as ondas no pé de cada campo são desenhadas na cor do papel, e um só desenho serve aos quatro campos.
Créditos
- Receita
- Ignacio Ferro
- Texto
- Texto original, CC BY 4.0
- Fontes
- Lexend (SIL OFL 1.1) · Lilita One (SIL OFL 1.1) · Chivo Mono (SIL OFL 1.1)
- Código
- MIT, como o Postext
Editar este texto ↗ (abre em uma nova aba)Pasta da receita no GitHub ↗ (abre em uma nova aba)


