Pular para o conteúdo principal
Receita número 52

Receitas · Capítulo 8 · Tabelas

Cardápio de bistrô: preços numa parada de tabulação

Um cardápio de bistrô de duas faces: preços rentes à direita numa parada de tabulação, vinhos numa tabela sem fios e um fio de latão de cada lado dos títulos.

Nesta página
  • Amostra em inglês: ainda sem edição em português
  • Refile 230 × 310 mm
  • 1 coluna
  • Noticia Text 10,5/14,5
  • Josefin Sans
  • Limelight
  • 2 páginas
  • Nível
  • Postext 1.57.1
  • Diagramado em 47 ms
  • 154 linhas de código

Em poucas palavras

Um cardápio de duas faces para um restaurante inventado de Paris. Mostra como levar cada preço até a borda direita com uma tabulação e como compor uma carta de vinhos numa tabela sem linhas visíveis.

O que você vai compor

O cardápio de outono do Les Tanneurs, um bistrô parisiense imaginário: uma só folha de 230 × 310 mm impressa dos dois lados. Na frente, um toldo listrado pende sobre o nome, composto em Limelight. Cada título de seção fica entre dois fios de latão que vão até as margens, com quatro pratos embaixo. Um prato é o nome francês em negrito com a guarnição, uma linha em inglês em itálico logo abaixo e o preço em negrito, alinhado à direita. Um disco verde-escuro com V marca os pratos vegetarianos, e uma pílula contornada com SG os sem glúten. Cada prato é um só parágrafo, e uma tabulação leva o preço até uma parada na margem direita. No verso, a carta de vinhos fica sob uma prateleira de garrafas, com os preços da taça e da garrafa em colunas encabeçadas por 12 cl e 75 cl, numa tabela sem fios e sem legenda.

Esta receita responde a

  • Como faço uma tabela com linhas de cabeçalho, células mescladas, larguras de coluna e alinhamento por célula?
  • Como faço chips em linha: teclas, etiquetas, bancos de palavras para exercícios?
  • Como componho ilustrações sem numeração: ornamentos, vinhetas, logotipos?
  • Como adiciono imagens e tabelas a partir do código (recursos) em vez de usar ![]() do Markdown?

A resposta curta

script.js · linhas 28–42no código completo
// Each course is a :::paragraphs group in the dish style. Its one tab stop stands at the end of
// the measure and ends there the text after the tab, so `:tab **7**` sets the price flush right
// however long the dish is. A backslash at the end of the line breaks it: the dish and its
// translation are one paragraph, and the price shares the dish's first line.
const dish = { id: 'dish', name: 'Dish', textAlign: 'left', // the card is centred; a dish is not
  tabStops: [{ position: 'end', align: 'end' }],
  spaceBetween: pt(LEAD / 2), // half a line between two dishes: each dish 2½ lines of LEAD
  marginTop: pt(LEAD), // a line of air under the course head
  indent: pt(LEAD / 4), endIndent: pt(LEAD / 4) }; // in line with the wine list's cell text
// The wine list stays a table: its prices stand in two columns under the heads 12 cl and 75 cl.
// The document's tableStyle turns off every rule and fill (#region wines).
const tableStyle = { rules: 'none', cellPadding: pt(LEAD / 4), // a row: 1½ lines of LEAD
  bodyFontFamily: TEXT, bodyFontSize: pt(BODY), bodyColor: col('ink'),
  headerFontFamily: LABEL, headerFontSize: pt(8.5), headerColor: col('wine'),
  headerBackgroundEnabled: false }; // header cells: the wine list's labels

Ingredientes

Tipografia
Limelight, Noticia Text, Josefin Sans (SIL OFL 1.1)
Materiais
  • The awning and the shelf of bottles, drawn in code in the page's palette (Ignacio Ferro, CC BY 4.0)

Preparo

#1 · Uma parada de tabulação onde vai o preço

O código está na resposta curta, mais acima. Cada seção é um grupo :::paragraphs{style="dish"}, um parágrafo por prato (estilos de parágrafo). O estilo do prato tem uma só parada, em 'end', o fim da medida, com align: 'end': o texto depois de uma tabulação termina nela. Assim, :tab **7** depois da guarnição e dos selos leva o preço até a margem direita, seja qual for o comprimento do prato (tabulações e paradas de tabulação). :tab absorve os espaços em volta dele, e a barra invertida no fim da linha é uma quebra de linha forçada, de modo que a tradução em itálico começa uma segunda linha do mesmo parágrafo e o preço fica na primeira. spaceBetween deixa meia linha entre dois pratos, e assim cada prato ocupa duas linhas e meia da entrelinha de 14,5 pt. indent e endIndent de um quarto de linha alinham os pratos com o texto das células da carta de vinhos no verso. Um parágrafo com tabulação é composto linha a linha; aqui todas as linhas são em bandeira de qualquer modo.

#2 · Um só tipo de recurso, no lugar e sem número

script.js · linhas 46–53no código completo
// No caption prefix and no caption, so no 'Table 1' line prints under the wine list. Placement
// 'here' sets each piece at its ::resource line; a list that outgrows the page is cut
// between rows and goes on at the head of the next one.
const resourceTypes = [{ id: 'menu', name: 'Menu', shortLabel: 'Menu', captionPrefix: '',
  numberingTemplate: '{n}', resetOn: 'never', counterFormat: 'decimal',
  defaultPlacement: { position: 'here' } }];
const piece = (id, kind, body) => ({ id, typeId: 'menu', kind, createdAt: 0, updatedAt: 0,
  ...body });

Os tipos de figura e de tabela que vêm no motor imprimem uma linha de legenda e fazem cada recurso flutuar até o primeiro espaço livre depois da primeira referência. O tipo menu não tem prefixo de legenda, e as peças dele não têm legenda, por isso nada se imprime sob os desenhos nem sob a carta de vinhos. Dê a ele captionPrefix: 'Menu' e uma linha numerada aparece sob cada peça, começando por “Menu 1.” sob o toldo, e o cardápio passa para quatro páginas. defaultPlacement põe a carta de vinhos e cada desenho na linha ::resource (inserção em bloco). Sem ele, a carta de vinhos flutua até o pé do verso, abaixo de Le Comptoir e do colofão. O toldo e as garrafas são recursos SVG do mesmo tipo, desenhados em código e registrados com o loadSvg do kit.

#3 · Mesclar as linhas de região

script.js · linhas 57–70no código completo
function wineList(tsv) {
  let m = { ...parseTSV(tsv, { headerRows: 1 }), columnWidths: [5, 1, 1] }; // the head row
  m.rows = m.rows.map((row, r) => row.map((cell, c) => (c === 0 ? cell : { ...cell, align: 'right',
    content: r > 0 && cell.content ? `**${cell.content}**` : cell.content }))); // as the dishes'
  m.rows.forEach(([first, ...rest], r) => { // a line with one field names a region
    if (r === 0 || !first.content || rest.some((cell) => cell.content)) return;
    // One cell across the table, centred on the card like the course heads; a label centred
    // in the first column alone would sit 22.6 mm left of them. The label face is the header's.
    m.rows[r][0] = { ...first, isHeader: true, align: 'center' };
    // mergeCells marks the two cells it covers hiddenBy (gotcha: merged-cells-hiddenby).
    m = mergeCells(m, { start: { row: r, col: 0 }, end: { row: r, col: 2 } });
  });
  return piece('wines', 'table', { table: { model: m } });
}

A carta de vinhos continua sendo uma tabela: os dois preços ficam em colunas sob os cabeçalhos, 12 cl e 75 cl, que uma fileira de paradas de tabulação deixaria sem cabeçalho. parseTSV(tsv, { headerRows: 1 }) lê a primeira linha como linha de cabeçalho, por isso Appellation · cépage, 12 cl e 75 cl saem sobre as colunas na fonte do cabeçalho, Josefin Sans. Uma linha com um só campo nomeia uma região. A célula dela vira uma célula de cabeçalho centralizada, e mergeCells a estende pelas três colunas e marca com hiddenBy as duas células que ela cobre (montar modelos de tabela). Centralizado só na primeira coluna, BLANCS ficaria 22,6 mm à esquerda do eixo em que La Cave e Le Comptoir estão centralizados. Uma linha em branco no TSV vira uma linha de células vazias, com uma linha e meia de altura, e é ela o respiro acima de Blancs e Rouges.

#4 · Pendurar um fio de cada lado do título de seção

script.js · linhas 74–88no código completo
// The title has no width, so it shrink-wraps its text, and 'top' centres it on the column. Each
// rule hangs off one edge of the title ('left-of', 'right-of'), 4 mm away, and 'fill' runs it
// to the column's edge: 66.7 mm beside PLATS, 56.2 mm beside the longer LE COMPTOIR.
const rule = (edge, x) => ({ kind: 'rule', id: `rule-${edge}`, color: col('brass'),
  thickness: pt(0.75), // heavier than the default 0.5 pt hairline
  placement: { anchor: { to: '#title', edge },
    size: { width: 'fill' }, // to the column's edge
    offset: { x: mm(x), y: pt(6) } } }); // 6 pt down: the middle of Limelight's capitals
const courseHead = { enabled: true, slot: { elements: [
  { kind: 'text', id: 'title', content: '{titleText}', fontFamily: DISPLAY, fontSize: pt(15),
    lineHeight: 0.96, // 14.4 pt: the title stays inside one 14.5 pt grid line
    textTransform: 'uppercase', color: col('wine'),
    placement: { anchor: { to: 'container', edge: 'top' } } },
  rule('left-of', -4), rule('right-of', 4),
] } };

Um título de seção é um design dentro da coluna. O elemento {titleText} não tem largura, de modo que a caixa dele é tão larga quanto as maiúsculas, e a âncora 'top' o centraliza na coluna. Cada fio pende de uma borda do título com 'left-of' ou 'right-of' e se estende até a borda da coluna (posicionamento de elementos), de modo que os fios ao lado de PLATS têm 66,7 mm e os ao lado de LE COMPTOIR 56,2 mm, cada um a 4 mm das letras. O lineHeight do título é um múltiplo, 0,96, que deixa a caixa com 14,4 pt, dentro de uma linha de 14,5 pt da grade. Com 1, a caixa tem 15 pt, cada título ocupa duas linhas e o cardápio passa para quatro páginas.

#5 · Selos como chips, letra miúda como estilos de parágrafo

script.js · linhas 92–110no código completo
// A chip is a box around inline text: the V disc is filled, the SG pill only outlined. A chip
// takes the weight of the text around it, so without bold the V is set in 400, a weight not loaded.
const badge = { fontFamily: LABEL, fontSize: pt(7.5), bold: true, // Josefin Sans 700
  borderRadius: pt(8), paddingY: em(0.1), gap: em(0.6) }; // radius clamped to a half-height
const chipStyles = [
  // V: paddingX makes the box as wide as it is tall, a disc. borderWidth 0 removes the default
  // outline, 0.5 pt of main-color, which would ring the green in wine red.
  { id: 'veg', name: 'Vegetarian', ...badge, paddingX: em(0.3), borderWidth: pt(0),
    background: col('bottle'), color: col('paper') },
  { id: 'gf', name: 'Gluten-free', ...badge, paddingX: em(0.45), backgroundEnabled: false,
    borderColor: col('bottle'), borderWidth: pt(0.6), color: col('bottle') },
];
// The notes under the desserts and the colophon on the back: smaller, on the card's axis, a
// line of air above each.
const paragraphStyles = [dish,
  { id: 'notes', name: 'Notes', fontSize: pt(9), marginTop: pt(LEAD) },
  { id: 'colophon', name: 'Colophon', fontSize: pt(7.5), color: col('muted'),
    marginTop: pt(LEAD) },
];

Um chip desenha uma caixa em volta de um trecho de texto dentro da linha (estilos de chip), por isso :chip[V]{style="veg"} digitado depois da guarnição põe o disco na linha francesa do prato, antes da tabulação. Os estilos de chip definem bold: true porque um chip assume o peso do texto em volta, 400 depois de uma guarnição, e FONTS carrega a Josefin Sans só em 700. As notas sob as sobremesas e o colofão do verso são blocos :::paragraphs em 9 e 7,5 pt, e os dois estilos têm um marginTop de uma linha (estilos de parágrafo). Sem essa margem, as notas começam na linha seguinte à linha em inglês da tábua de queijos, como se fizessem parte do prato.

#6 · Centralizar o cardápio num só eixo

script.js · linhas 114–126no código completo
// bodyText (in config) centres the lines under the name and the notes; only the dishes and the
// wine list keep a left edge. Ragged text is hyphenated only with bodyText.hyphenation.ragged,
// so no word on this card is divided, the French dish names included. The config's locale
// names each edition's language, English or Spanish, for the bundle the Sandbox opens.
const headings = { fontFamily: DISPLAY, fontWeight: 400, color: col('wine'), textAlign: 'center',
  levels: [ // Limelight ships one weight, 400, and no italic
    // The H1 break is off: by default an H1 opens a recto, which would part the name from the
    // awning and La Cave from its bottles.
    { level: 1, fontSize: pt(48), lineHeight: pt(3 * LEAD), breakBefore: { enabled: false },
      marginTop: pt(LEAD), marginBottom: pt(0) }, // three grid lines, one of air above
    { level: 2, lineHeight: pt(LEAD), advancedDesign: courseHead, // one line; #region heads
      marginTop: pt(LEAD), marginBottom: pt(0) }, // the dishes below add a line of their own
  ] };

headings.textAlign e bodyText.textAlign põem na linha central do cardápio tudo menos os pratos e a carta de vinhos. lineHeight: pt(3 * LEAD) dá ao nome de 48 pt três linhas da grade. Sem isso, o nome usa a entrelinha padrão e ocupa quatro linhas, a segunda linha de notas vai para uma página só dela e o cardápio passa para quatro páginas. O nível 1 desativa a quebra do H1, breakBefore: { enabled: false }, porque o nome e La Cave pertencem à página do desenho acima deles. Deixe o padrão, { enabled: true, parity: 'always-odd' }, e cada desenho fica sozinho numa página, sete páginas ao todo. A configuração não define locale: nada neste cardápio é justificado, e o texto em bandeira só é hifenizado com bodyText.hyphenation.ragged ativado.

A receita completa

Sandbox
// ═══ Postext Cookbook · Nº 052 · Bistro menu: prices on a tab stop ═══════════════════
// https://postext.dev/en/cookbook/bistro-menu
// Code: MIT · Text: original, in French (CC BY 4.0) · Drawings: generated in code (CC BY 4.0)
// Fonts: Limelight, Noticia Text, Josefin Sans (SIL OFL 1.1) · Needs postext ≥ 1.25.0
// The autumn menu of an imaginary Paris bistro: two sides of one card, each dish a paragraph
// whose price a tab sends to the right margin, the wine list a table with no rules.
import {
  buildDocumentWithFonts, prepareFonts, renderPageToCanvas, registerResourceImage, parseTSV,
  mergeCells,
} from 'https://esm.sh/postext';

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

// ─── 1 · Design ─────────────────────────────────────────────────────────────
const palette = { ink: '#1f2a24', paper: '#f6efdf', // green-black text on cream card
  wine: '#6d1f2c', brass: '#a9823a', // the name, heads and labels; rules and the drawings' metal
  straw: '#e8d4a8', bottle: '#2f4235', sage: '#8a9a78', // awning stripes and labels; glass
  muted: '#6b6457' }; // the colophon
const col = (id) => ({ hex: palette[id], model: 'hex', paletteId: id });
// The engine's defaults link to 'main-color' (#295aa3, a blue); this palette makes it the wine red.
const colorPalette = Object.entries({ ...palette, 'main-color': palette.wine })
  .map(([id, hex]) => ({ id, name: id, value: { hex, model: 'hex' } }));
const [TEXT, DISPLAY, LABEL] = ['Noticia Text', 'Limelight', 'Josefin Sans'];
const [BODY, LEAD] = [10.5, 14.5]; // pt: the text, and the leading every table row keeps

// #region answer: dish on the left, price flush right: a tab stop at the end of the measure
// Each course is a :::paragraphs group in the dish style. Its one tab stop stands at the end of
// the measure and ends there the text after the tab, so `:tab **7**` sets the price flush right
// however long the dish is. A backslash at the end of the line breaks it: the dish and its
// translation are one paragraph, and the price shares the dish's first line.
const dish = { id: 'dish', name: 'Dish', textAlign: 'left', // the card is centred; a dish is not
  tabStops: [{ position: 'end', align: 'end' }],
  spaceBetween: pt(LEAD / 2), // half a line between two dishes: each dish 2½ lines of LEAD
  marginTop: pt(LEAD), // a line of air under the course head
  indent: pt(LEAD / 4), endIndent: pt(LEAD / 4) }; // in line with the wine list's cell text
// The wine list stays a table: its prices stand in two columns under the heads 12 cl and 75 cl.
// The document's tableStyle turns off every rule and fill (#region wines).
const tableStyle = { rules: 'none', cellPadding: pt(LEAD / 4), // a row: 1½ lines of LEAD
  bodyFontFamily: TEXT, bodyFontSize: pt(BODY), bodyColor: col('ink'),
  headerFontFamily: LABEL, headerFontSize: pt(8.5), headerColor: col('wine'),
  headerBackgroundEnabled: false }; // header cells: the wine list's labels
// #endregion

// #region type: one resource type for the whole card: set where it stands, never numbered
// No caption prefix and no caption, so no 'Table 1' line prints under the wine list. Placement
// 'here' sets each piece at its ::resource line; a list that outgrows the page is cut
// between rows and goes on at the head of the next one.

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

#Parar os fios num comprimento fixo

Uma largura fixa no lugar de 'fill' deixa cada fio com 20 mm, a 4 mm do título, e assim o par fica mais perto do centro ao lado de PLATS do que ao lado de LE COMPTOIR.

-    size: { width: 'fill' }, // to the column's edge
+    size: { width: mm(20) }, // 20 mm, wherever the title ends

#Levar pontos até o preço

Um preenchimento ocupa o espaço antes da parada. '. ' repete um ponto e um espaço, de meio em depois do último selo ou da última palavra do prato até meio em antes do preço.

-  tabStops: [{ position: 'end', align: 'end' }],
+  tabStops: [{ position: 'end', align: 'end', leader: '. ' }],

#Riscar a carta de vinhos como um livro-caixa

rules: 'horizontal' desenha um fio fino de latão de 0,5 pt acima e abaixo de cada linha da carta de vinhos. Os fios não ocupam espaço, por isso os dois lados mantêm a diagramação, e as linhas em branco acima de Blancs e Rouges ganham também um par de fios.

-const tableStyle = { rules: 'none', cellPadding: pt(LEAD / 4), // a row: 1½ lines of LEAD
+const tableStyle = { rules: 'horizontal', borderColor: col('brass'),
+  borderWidth: pt(0.5), cellPadding: pt(LEAD / 4),

Erros comuns

Erro comum

Células mescladas precisam de hiddenBy: use mergeCells

As células são posicionadas pela posição no array da linha, então uma célula mesclada precisa de células de preenchimento marcadas com hiddenBy onde ela se estende; omiti-las, como no HTML, desloca todas as colunas seguintes. Crie as mesclagens com mergeCells. Desde o postext 1.5, uma tabela com grade irregular é informada em doc.contentWarnings como raggedTableGrid, e parseTSV(text, { headerRows }) marca as linhas de cabeçalho. Tabelas a partir de dados →

Deixe espaço para o preço na primeira linha do prato. Quando o prato e a guarnição passam do lugar de que o preço precisa, a parada leva a última palavra do prato para a linha seguinte junto com o preço, e a linha em inglês vem depois deles: o prato passa a ocupar três linhas e a seção termina uma linha mais abaixo.

Créditos

Texto
Texto original, CC BY 4.0
Imagens
  • The awning and the shelf of bottles, drawn in code in the page's palette · Ignacio Ferro · CC BY 4.0
Fontes
Limelight (SIL OFL 1.1) · Noticia Text (SIL OFL 1.1) · Josefin Sans (SIL OFL 1.1)
Sandbox