fix: a table takes the vertical space LibreOffice gives it

Two ways a table's height was off. Its space above was a margin, so it
collapsed against the paragraph above instead of adding to it — now it rides
--space-before like a paragraph's. And every cell border paints a whole pixel
however thin the file declares it, where LibreOffice reserves the declared
width; the excess now comes off the cell's padding-bottom, 0.25mm a row.
This commit is contained in:
Steffen Becker committed 2026-08-10 18:34:32 +00:00
1 parent 819f51587e
commit b7f6328005
5 files changed
+52 -11

No files matched your search

+9 -1
View File
@@ -93,7 +93,9 @@ We deliberately keep TipTap's `resizable: false` (so its own columnResizing plug
ones) — ODF `fo:margin-top`/`-bottom` on the table style, which LibreOffice honours like a
paragraph's. Rendered on the `.tableWrapper` (`TableView`, plus the inline style for the static
paths). Word has no table-level spacing, so it round-trips through ODF only. the Math Guide's callout
tables carry 0.109/0.409cm and lost half a line each without it.
tables carry 0.109/0.409cm and lost half a line each without it. The space **above** rides
`--space-before`, so the document's spacing model adds it to the block above instead of
collapsing against it, exactly as a paragraph's does.
## Cell metrics measured against LibreOffice
@@ -102,6 +104,12 @@ We deliberately keep TipTap's `resizable: false` (so its own columnResizing plug
model only. Measured on the Math Guide: the table row grew 1mm per row without it. `pageBreaks.ts`
excludes cell leaves from its page-top-drop detection, or that missing padding would read
as a decoration to add back.
- **A painted border is always a whole pixel**, whatever width the file declares — Chromium
floors it, LibreOffice reserves the declared width (the Math Guide's cells ask for a 0.05pt hairline).
The excess comes off the cell's `padding-bottom` (`--border-over`, `tableCellBorders.ts`;
the bottom side only, since `border-collapse` draws one line per boundary), which is why the
cell padding rides four custom properties rather than one shorthand. 0.25mm a row, a page
over the Math Guide's length.
- **`<th>` carries no UA defaults.** A repeating ODF header row (`table:table-header-rows`)
becomes a `tableHeader`, and the browser centres and bolds it — neither Word nor LibreOffice
does. `editor.css` resets both, so the cell follows its own style (the "header row" preset's
+15 -1
View File
@@ -57,6 +57,16 @@ export function cssBorder(value: string): string | null {
return `${px}px solid ${b.color}`;
}
// What the painted border costs the row beyond the width the file declares: Chromium
// floors every border to a whole pixel, LibreOffice reserves the declared width (a
// 0.05pt hairline is next to nothing). editor.css takes it off the cell's padding.
export function borderOvershootPx(value: string): number {
const b = parseBorderAttr(value);
if (b === null || b === 'none') return 0;
const declared = (b.widthPt * 96) / 72;
return Math.round((Math.max(1, Math.round(declared)) - declared) * 1000) / 1000;
}
const SIDE_META: Record<BorderSide, { data: string; css: string }> = {
borderTop: { data: 'data-border-top', css: 'border-top' },
borderRight: { data: 'data-border-right', css: 'border-right' },
@@ -216,7 +226,11 @@ export const TableCellBorders = Extension.create({
if (!v) return {};
const css = cssBorder(v);
if (!css) return {};
return { [SIDE_META[side].data]: v, style: `${SIDE_META[side].css}: ${css}` };
// Only the bottom one: with border-collapse a boundary draws a single
// line, so compensating both sides of it would take the excess twice.
const over = side === 'borderBottom' ? borderOvershootPx(v) : 0;
const style = `${SIDE_META[side].css}: ${css}` + (over ? `; --border-over: ${over}px` : '');
return { [SIDE_META[side].data]: v, style };
},
},
]),
@@ -32,11 +32,14 @@ export function parseCellPadding(value: unknown): CellPadding | null {
return nums.length === 4 && nums.every((n) => Number.isFinite(n)) ? cellPaddingAttr(nums) : null;
}
// One custom property carrying the whole shorthand; editor.css reads it with the
// default as its fallback, so nothing to write for an ordinary table.
// One custom property per side; editor.css reads them with the default as their
// fallback, so nothing to write for an ordinary table. Per side rather than one
// shorthand because the bottom one is what the border overshoot comes off (editor.css).
export const CELL_PAD_VARS = ['--cell-pad-t', '--cell-pad-r', '--cell-pad-b', '--cell-pad-l'];
export function cellPaddingStyle(value: unknown): string | null {
const p = parseCellPadding(value);
return p ? `--cell-pad:${p.map((n) => `${n}cm`).join(' ')}` : null;
return p ? CELL_PAD_VARS.map((v, i) => `${v}:${p[i]}cm`).join(';') : null;
}
export const TableCellPadding = Extension.create({
@@ -51,7 +54,8 @@ export const TableCellPadding = Extension.create({
attributes: {
cellPadding: {
default: null,
parseHTML: (element: HTMLElement) => parseCellPadding(element.style.getPropertyValue('--cell-pad')),
parseHTML: (element: HTMLElement) =>
parseCellPadding(CELL_PAD_VARS.map((v) => element.style.getPropertyValue(v)).join(' ')),
renderHTML: (attributes: Record<string, unknown>) => {
const style = cellPaddingStyle(attributes.cellPadding);
return style ? { style } : {};
+9 -4
View File
@@ -1,5 +1,5 @@
import type { Node as PMNode } from '@tiptap/pm/model';
import { parseCellPadding } from './tableCellPadding';
import { CELL_PAD_VARS, parseCellPadding } from './tableCellPadding';
import type { ViewMutationRecord } from '@tiptap/pm/view';
// Custom table node view: <colgroup> uses percentage widths and the table stays at
@@ -46,8 +46,11 @@ function applyMargins(node: PMNode, wrapper: HTMLElement): void {
const mb = (node.attrs.marginBottom as number) || 0;
wrapper.style.marginLeft = ml ? `${ml}cm` : '';
wrapper.style.marginRight = mr ? `${mr}cm` : '';
wrapper.style.marginTop = mt ? `${mt}cm` : '';
wrapper.style.marginBottom = mb ? `${mb}cm` : '';
// Space above rides --space-before so editor.css can add it to the block above
// instead of collapsing against it (storage/spacingModel.ts).
if (mt) wrapper.style.setProperty('--space-before', `${mt}cm`);
else wrapper.style.removeProperty('--space-before');
}
// The node view never calls the node's renderHTML, so the table-style hook the generated
@@ -64,8 +67,10 @@ function applyTableStyleAttr(node: PMNode, table: HTMLElement): void {
// Also bypassed by the node view: the cell margins editor.css reads off the table.
function applyCellPadding(node: PMNode, table: HTMLElement): void {
const p = parseCellPadding(node.attrs.cellPadding);
if (p) table.style.setProperty('--cell-pad', p.map((n) => `${n}cm`).join(' '));
else table.style.removeProperty('--cell-pad');
CELL_PAD_VARS.forEach((v, i) => {
if (p) table.style.setProperty(v, `${p[i]}cm`);
else table.style.removeProperty(v);
});
}
function buildColgroup(node: PMNode, colgroup: HTMLElement): void {
+11 -1
View File
@@ -625,6 +625,12 @@
margin-left/-right here (tableView.ts), which is what the export writes. */
margin: 0;
overflow-x: auto;
/* The table's space above adds to the block above it, as a paragraph's does. */
padding-top: var(--space-before);
}
.paper[data-spacing-model='max'] .tiptap .tableWrapper {
padding-top: 0;
margin-top: var(--space-before);
}
.paper .tiptap table {
@@ -640,7 +646,11 @@
.paper .tiptap td,
.paper .tiptap th {
border: 1px solid #000;
padding: var(--cell-pad, 0 0.19cm);
padding: var(--cell-pad-t, 0) var(--cell-pad-r, 0.19cm) var(--cell-pad-b, 0) var(--cell-pad-l, 0.19cm);
/* A painted border is a whole pixel wide whatever the file declares, so the excess
comes off here — else a long table grows a line every few rows
(tableCellBorders.ts). */
padding-bottom: max(0px, calc(var(--cell-pad-b, 0px) - var(--border-over, 0px)));
vertical-align: top;
/* A repeating header row is a <th>, and no word processor centres or bolds its text
for that reason — drop the two UA defaults so the cell follows its own style. */