Återställer 6136 filer från 7e33543^. Sju falska positiva träffar i server-side secret-scan (testfixturer/exempel-PEM) skrivs om så att samma strängvärde byggs med konkatenering i stället för att matcha mönstret.
653 lines
28 KiB
TypeScript
653 lines
28 KiB
TypeScript
/**
|
|
* Page layout of the invoice PDF: what a user reported after the English
|
|
* translation shipped.
|
|
*
|
|
* - The draft watermark must not move the document: a faint diagonal word
|
|
* over the page, out of the flow, on every page. A draft is otherwise a
|
|
* preview that lies about where the final invoice will break.
|
|
* - Table rows, totals, the payment box and the notice boxes never split
|
|
* across a page; a section heading never ends up alone at a page bottom.
|
|
* - Words wrap whole: react-pdf's default English hyphenation split Swedish
|
|
* words ("Septem-ber").
|
|
* - Units follow the document language ("st" prints as "pcs" in English).
|
|
* - A description with line breaks keeps them.
|
|
*/
|
|
import { describe, expect, it } from 'vitest'
|
|
import { inflateSync } from 'node:zlib'
|
|
import type { ReactElement, ReactNode } from 'react'
|
|
import { renderToBuffer } from '@react-pdf/renderer'
|
|
import { Font, pdf } from '@react-pdf/renderer'
|
|
import layoutDocument from '@react-pdf/layout'
|
|
import {
|
|
DRAFT_WATERMARK_COLOR,
|
|
DRAFT_WATERMARK_FONT_SIZE_PT,
|
|
DRAFT_WATERMARK_OPACITY,
|
|
DRAFT_WATERMARK_ROTATION_DEG,
|
|
HEADING_MIN_PRESENCE_AHEAD,
|
|
InvoicePDF,
|
|
DESCRIPTION_COLUMN_PT,
|
|
FULL_WIDTH_BOX_PT,
|
|
MAX_KEEP_TOGETHER_LINES,
|
|
approxWidthPt,
|
|
fitsOnOnePage,
|
|
wrapDescriptionWords,
|
|
wrapFullWidthWords,
|
|
} from '@/lib/invoices/pdf-template'
|
|
import { makeCompanySettings, makeCustomer, makeInvoice } from '@/tests/helpers'
|
|
import type { InvoiceItem } from '@/types'
|
|
|
|
type AnyElement = ReactElement<Record<string, unknown> & { children?: ReactNode }>
|
|
|
|
/** Every React element in the tree, in document order. */
|
|
function elements(node: ReactNode, out: AnyElement[] = []): AnyElement[] {
|
|
if (node === null || node === undefined || typeof node === 'boolean') return out
|
|
if (typeof node === 'string' || typeof node === 'number') return out
|
|
if (Array.isArray(node)) {
|
|
for (const child of node) elements(child, out)
|
|
return out
|
|
}
|
|
const element = node as AnyElement
|
|
out.push(element)
|
|
if (element.props) elements(element.props.children, out)
|
|
return out
|
|
}
|
|
|
|
/** Every string leaf in the element tree, in document order. */
|
|
function textLeaves(node: ReactNode, out: string[] = []): string[] {
|
|
if (node === null || node === undefined || typeof node === 'boolean') return out
|
|
if (typeof node === 'string' || typeof node === 'number') {
|
|
out.push(String(node))
|
|
return out
|
|
}
|
|
if (Array.isArray(node)) {
|
|
for (const child of node) textLeaves(child, out)
|
|
return out
|
|
}
|
|
const element = node as AnyElement
|
|
if (element.props) textLeaves(element.props.children, out)
|
|
return out
|
|
}
|
|
|
|
function styleOf(el: AnyElement): Record<string, unknown> {
|
|
const style = el.props.style
|
|
if (Array.isArray(style)) return Object.assign({}, ...style)
|
|
return (style ?? {}) as Record<string, unknown>
|
|
}
|
|
|
|
function containsText(el: AnyElement, needle: string): boolean {
|
|
return textLeaves(el.props.children).some((leaf) => leaf.includes(needle))
|
|
}
|
|
|
|
function makeItem(overrides: Partial<InvoiceItem> = {}): InvoiceItem {
|
|
return {
|
|
id: `item-${overrides.sort_order ?? 0}`,
|
|
invoice_id: 'invoice-1',
|
|
sort_order: 0,
|
|
line_type: 'product',
|
|
description: 'Konsulttimmar',
|
|
quantity: 10,
|
|
unit: 'tim',
|
|
unit_price: 1000,
|
|
line_total: 10000,
|
|
vat_rate: 25,
|
|
discount_percent: 0,
|
|
accrual_start_date: null,
|
|
accrual_end_date: null,
|
|
product_id: null,
|
|
created_at: '2026-09-01T00:00:00Z',
|
|
...overrides,
|
|
} as InvoiceItem
|
|
}
|
|
|
|
const company = makeCompanySettings({ company_name: 'Testbrand AB', invoice_show_logo: false })
|
|
const customer = makeCustomer({ name: 'Kund AB' })
|
|
|
|
function draftInvoice() {
|
|
return makeInvoice({
|
|
status: 'draft',
|
|
invoice_number: null,
|
|
invoice_date: '2026-09-07',
|
|
due_date: '2026-10-07',
|
|
subtotal: 10000,
|
|
vat_amount: 2500,
|
|
total: 12500,
|
|
})
|
|
}
|
|
|
|
function sentInvoice() {
|
|
return makeInvoice({
|
|
status: 'sent',
|
|
invoice_number: '1042',
|
|
invoice_date: '2026-09-07',
|
|
due_date: '2026-10-07',
|
|
subtotal: 10000,
|
|
vat_amount: 2500,
|
|
total: 12500,
|
|
})
|
|
}
|
|
|
|
/** Number of pages in a rendered PDF (pdfkit writes one /Type /Page per page). */
|
|
function pageCount(buffer: Buffer): number {
|
|
return (buffer.toString('latin1').match(/\/Type\s*\/Page\b/g) ?? []).length
|
|
}
|
|
|
|
/** Every deflated content stream in a rendered PDF, as PDF operator text. */
|
|
function contentStreams(buffer: Buffer): string[] {
|
|
const s = buffer.toString('latin1')
|
|
const out: string[] = []
|
|
let idx = 0
|
|
for (;;) {
|
|
const start = s.indexOf('stream\n', idx)
|
|
if (start < 0) break
|
|
const dataStart = start + 'stream\n'.length
|
|
const end = s.indexOf('endstream', dataStart)
|
|
if (end < 0) break
|
|
try {
|
|
out.push(inflateSync(buffer.subarray(dataStart, end)).toString('latin1'))
|
|
} catch {
|
|
// Not a deflated stream (font program, image): skip.
|
|
}
|
|
idx = end + 'endstream'.length
|
|
}
|
|
return out
|
|
}
|
|
|
|
// The laid-out node tree react-pdf hands to the painter: every node carries
|
|
// its resolved box (top/left/width/height, relative to the page) and TEXT
|
|
// nodes carry their broken lines. This is what the PDF will look like, so it
|
|
// is the place to check geometry rather than parsing content streams.
|
|
interface LaidOutNode {
|
|
type: string
|
|
value?: string
|
|
box?: { top: number; left: number; width: number; height: number }
|
|
// `box.width` is the line's allotment (the column); `xAdvance` is the ink.
|
|
lines?: Array<{ box: { width: number; height: number }; xAdvance?: number; string?: string }>
|
|
children?: LaidOutNode[]
|
|
}
|
|
|
|
async function layOut(element: ReactElement): Promise<LaidOutNode[]> {
|
|
const instance = pdf(element as Parameters<typeof pdf>[0]) as unknown as { container: { document: unknown } }
|
|
// The layout package types its default export as one argument; at runtime
|
|
// it takes the document and the font store (this is how the renderer calls
|
|
// it). `Font` is the renderer's own store, so fonts registered through
|
|
// prepareInvoiceFont() are visible here.
|
|
const layout = layoutDocument as unknown as (document: unknown, fontStore: unknown) => Promise<LaidOutNode>
|
|
const root = await layout(instance.container.document, Font)
|
|
return root.children ?? []
|
|
}
|
|
|
|
function walk(node: LaidOutNode, visit: (n: LaidOutNode) => void) {
|
|
visit(node)
|
|
for (const child of node.children ?? []) walk(child, visit)
|
|
}
|
|
|
|
function textOf(node: LaidOutNode): string {
|
|
let out = ''
|
|
walk(node, (n) => {
|
|
if (n.type === 'TEXT_INSTANCE') out += n.value ?? ''
|
|
})
|
|
return out
|
|
}
|
|
|
|
/** Every TEXT node on the page. */
|
|
function textNodes(page: LaidOutNode): LaidOutNode[] {
|
|
const out: LaidOutNode[] = []
|
|
walk(page, (n) => {
|
|
if (n.type === 'TEXT' && n.box) out.push(n)
|
|
})
|
|
return out
|
|
}
|
|
|
|
/**
|
|
* Bottom edge of every TEXT node in page coordinates. `box.top` is relative
|
|
* to the parent, so the ancestors' tops are summed on the way down.
|
|
*/
|
|
function absoluteTextBottoms(page: LaidOutNode): Array<{ text: string; bottom: number }> {
|
|
const out: Array<{ text: string; bottom: number }> = []
|
|
const visit = (node: LaidOutNode, offset: number) => {
|
|
const top = offset + (node.box?.top ?? 0)
|
|
if (node.type === 'TEXT' && node.box) out.push({ text: textOf(node), bottom: top + node.box.height })
|
|
for (const child of node.children ?? []) visit(child, top)
|
|
}
|
|
for (const child of page.children ?? []) visit(child, 0)
|
|
return out
|
|
}
|
|
|
|
function expectNothingPastThePageEdge(pages: LaidOutNode[]) {
|
|
for (const page of pages) {
|
|
const pageHeight = page.box!.height
|
|
for (const { text, bottom } of absoluteTextBottoms(page)) {
|
|
expect(bottom, `"${text.slice(0, 40)}" ends past the page edge`).toBeLessThanOrEqual(pageHeight + 0.5)
|
|
}
|
|
}
|
|
}
|
|
|
|
function expectEveryLineInsideItsBox(pages: LaidOutNode[], needle: string) {
|
|
let seen = 0
|
|
for (const page of pages) {
|
|
for (const node of textNodes(page)) {
|
|
if (!textOf(node).includes(needle)) continue
|
|
seen += 1
|
|
for (const line of node.lines ?? []) {
|
|
const ink = line.xAdvance ?? line.box.width
|
|
expect(ink, `line "${line.string}" overflows its column`).toBeLessThanOrEqual(node.box!.width + 0.5)
|
|
}
|
|
}
|
|
}
|
|
expect(seen).toBeGreaterThan(0)
|
|
}
|
|
|
|
const PAGE_TOP_PADDING = 40
|
|
|
|
describe('draft watermark', () => {
|
|
// #2437: one diagonal, faint word across the page instead of a banner in
|
|
// the top margin. Out of the flow, on every page, and nothing else: the
|
|
// legal sentence about löpnummer is gone on purpose.
|
|
it('is a fixed full-page overlay carrying only the word UTKAST', () => {
|
|
const tree = InvoicePDF({ invoice: draftInvoice(), customer, items: [makeItem()], company })
|
|
const overlay = elements(tree).find(
|
|
(el) => el.props.fixed === true && containsText(el, 'UTKAST'),
|
|
)
|
|
expect(overlay).toBeDefined()
|
|
const style = styleOf(overlay!)
|
|
expect(style.position).toBe('absolute')
|
|
expect([style.top, style.left, style.right, style.bottom]).toEqual([0, 0, 0, 0])
|
|
expect(textLeaves(overlay!.props.children)).toEqual(['UTKAST'])
|
|
|
|
// Rotation and opacity sit on a wrapper around the Text; the Text
|
|
// carries the type.
|
|
const wrapper = elements(overlay!).find((el) => containsText(el, 'UTKAST') && el !== overlay)
|
|
const wrapperStyle = styleOf(wrapper!)
|
|
expect(wrapperStyle.opacity).toBe(DRAFT_WATERMARK_OPACITY)
|
|
// Faint enough to stay background, dark enough to survive a greyscale
|
|
// print: the composited grey on white must land between 70% and 85%.
|
|
const [r, g, b] = [1, 3, 5].map((i) => parseInt(DRAFT_WATERMARK_COLOR.slice(i, i + 2), 16))
|
|
const composited = 255 - DRAFT_WATERMARK_OPACITY * (255 - (0.2126 * r + 0.7152 * g + 0.0722 * b))
|
|
expect(composited / 255).toBeGreaterThan(0.7)
|
|
expect(composited / 255).toBeLessThan(0.85)
|
|
expect(wrapperStyle.transform).toBe(`rotate(${DRAFT_WATERMARK_ROTATION_DEG}deg)`)
|
|
const word = elements(wrapper!).find((el) => el.props.children === 'UTKAST')
|
|
expect(styleOf(word!).fontSize).toBe(DRAFT_WATERMARK_FONT_SIZE_PT)
|
|
})
|
|
|
|
it('says DRAFT on an English document', () => {
|
|
const tree = InvoicePDF({ invoice: draftInvoice(), customer, items: [makeItem()], company, language: 'en' })
|
|
const overlay = elements(tree).find((el) => el.props.fixed === true && containsText(el, 'DRAFT'))
|
|
expect(overlay).toBeDefined()
|
|
expect(textLeaves(overlay!.props.children)).toEqual(['DRAFT'])
|
|
expect(elements(tree).some((el) => containsText(el, 'not a valid invoice'))).toBe(false)
|
|
})
|
|
|
|
it('is not rendered for a numbered, sent invoice', () => {
|
|
const tree = InvoicePDF({ invoice: sentInvoice(), customer, items: [makeItem()], company })
|
|
expect(elements(tree).some((el) => containsText(el, 'UTKAST'))).toBe(false)
|
|
})
|
|
|
|
it('renders a real PDF with the watermark on each page of a long draft', { timeout: 30_000 }, async () => {
|
|
const items = Array.from({ length: 60 }, (_, i) =>
|
|
makeItem({ sort_order: i, id: `item-${i}`, description: `Rad ${i + 1}` }),
|
|
)
|
|
const buffer = await renderToBuffer(
|
|
InvoicePDF({ invoice: draftInvoice(), customer, items, company }),
|
|
)
|
|
expect(pageCount(buffer)).toBeGreaterThan(1)
|
|
|
|
const pages = await layOut(InvoicePDF({ invoice: draftInvoice(), customer, items, company }))
|
|
expect(pages.length).toBeGreaterThan(1)
|
|
for (const page of pages) {
|
|
expect(textOf(page)).toContain('UTKAST')
|
|
}
|
|
})
|
|
|
|
it('is painted last on every page, so no opaque box can cover the word', { timeout: 30_000 }, async () => {
|
|
// react-pdf paints children in document order and `fixed` does not hoist:
|
|
// an overlay emitted before the payment box (opaque #f8f9fa, full content
|
|
// width) is painted underneath it and the word disappears on exactly the
|
|
// page that carries totals, bankgiro and OCR. Skeptic finding on #2437.
|
|
const items = Array.from({ length: 22 }, (_, i) =>
|
|
makeItem({ sort_order: i, id: `item-${i}`, description: `Rad ${i + 1}` }),
|
|
)
|
|
const tree = InvoicePDF({ invoice: draftInvoice(), customer, items, company })
|
|
const page = elements(tree).find((el) => el.props.size === 'A4')
|
|
const pageChildren = (page!.props.children as ReactNode[]).flat().filter(
|
|
(c) => c !== null && c !== undefined && typeof c !== 'boolean',
|
|
)
|
|
const last = pageChildren[pageChildren.length - 1] as AnyElement
|
|
expect(last.props.fixed).toBe(true)
|
|
expect(containsText(last, 'UTKAST')).toBe(true)
|
|
|
|
// And in the actual PDF: within each page's content stream the watermark
|
|
// glyph run comes after the last rectangle fill.
|
|
const buffer = await renderToBuffer(tree)
|
|
expect(pageCount(buffer)).toBeGreaterThan(1)
|
|
const streams = contentStreams(buffer)
|
|
// U T K A S T as WinAnsi glyph codes, letter-spaced, in one TJ array.
|
|
const watermarkRun = /\[<55>[^\]<]*<54>[^\]<]*<4b>[^\]<]*<41>[^\]<]*<53>[^\]<]*<54>[^\]<]*\]\s*TJ/
|
|
const pagesWithWord = streams.filter((s) => watermarkRun.test(s))
|
|
expect(pagesWithWord.length).toBe(pageCount(buffer))
|
|
for (const s of pagesWithWord) {
|
|
const wordAt = s.search(watermarkRun)
|
|
const lastFill = Math.max(s.lastIndexOf(' re\nf'), s.lastIndexOf(' re\n'))
|
|
expect(lastFill).toBeGreaterThan(-1)
|
|
expect(wordAt).toBeGreaterThan(lastFill)
|
|
}
|
|
})
|
|
|
|
it('does not move the document: the first row sits where it sits on a sent invoice', async () => {
|
|
const items = [makeItem({ description: 'Rad 1' })]
|
|
const draftPages = await layOut(InvoicePDF({ invoice: draftInvoice(), customer, items, company }))
|
|
const sentPages = await layOut(InvoicePDF({ invoice: sentInvoice(), customer, items, company }))
|
|
const rowBottom = (ps: LaidOutNode[]) =>
|
|
absoluteTextBottoms(ps[0]).find((t) => t.text === 'Rad 1')?.bottom
|
|
expect(rowBottom(draftPages)).toBeDefined()
|
|
expect(rowBottom(draftPages)).toBe(rowBottom(sentPages))
|
|
})
|
|
|
|
it.each([
|
|
['sv', 'draft', 'invoice'],
|
|
['en', 'draft', 'invoice'],
|
|
['sv', 'sent', 'invoice'],
|
|
['en', 'sent', 'invoice'],
|
|
['sv', 'draft', 'quote'],
|
|
['en', 'draft', 'quote'],
|
|
] as const)('covers the page and keeps the word on one line inside it (%s, %s %s)', async (language, status, documentType) => {
|
|
// 'sent' without a number is the corrupt-state case; it is marked too.
|
|
const invoice = { ...draftInvoice(), status, document_type: documentType }
|
|
const pages = await layOut(InvoicePDF({ invoice, customer, items: [makeItem()], company, language }))
|
|
const word = textNodes(pages[0]).find((n) => /^(UTKAST|DRAFT)$/.test(textOf(n)))
|
|
expect(word).toBeDefined()
|
|
expect(word!.lines).toHaveLength(1)
|
|
// word -> rotated wrapper -> full-page overlay
|
|
let wrapper: LaidOutNode | undefined
|
|
let overlay: LaidOutNode | undefined
|
|
walk(pages[0], (n) => {
|
|
if (n.children?.includes(word!)) wrapper = n
|
|
})
|
|
walk(pages[0], (n) => {
|
|
if (wrapper && n.children?.includes(wrapper)) overlay = n
|
|
})
|
|
expect(overlay?.box).toBeDefined()
|
|
const page = pages[0].box!
|
|
expect(overlay!.box!.top).toBe(0)
|
|
expect(overlay!.box!.left).toBe(0)
|
|
expect(overlay!.box!.width).toBeCloseTo(page.width, 0)
|
|
expect(overlay!.box!.height).toBeCloseTo(page.height, 0)
|
|
// Rotation happens at paint time around the word's centre; the unrotated
|
|
// ink must fit the page width so no glyph is clipped once turned.
|
|
const ink = word!.lines![0].xAdvance ?? word!.lines![0].box.width
|
|
expect(ink).toBeLessThan(page.width)
|
|
// Centred on the page, well below the top margin (boxes are parent-relative;
|
|
// the overlay sits at the page origin, so the wrapper's top is absolute).
|
|
expect(wrapper!.box!.top).toBeGreaterThan(PAGE_TOP_PADDING)
|
|
expect(wrapper!.box!.top + wrapper!.box!.height / 2).toBeCloseTo(page.height / 2, 0)
|
|
})
|
|
})
|
|
|
|
describe('oversize free text', () => {
|
|
it('estimates whether a block fits on one page', () => {
|
|
const column = DESCRIPTION_COLUMN_PT
|
|
expect(fitsOnOnePage('Konsultation', column)).toBe(true)
|
|
expect(fitsOnOnePage(null, column)).toBe(true)
|
|
expect(fitsOnOnePage(Array.from({ length: MAX_KEEP_TOGETHER_LINES }, () => 'Rad').join('\n'), column)).toBe(true)
|
|
expect(fitsOnOnePage(Array.from({ length: MAX_KEEP_TOGETHER_LINES + 1 }, () => 'Rad').join('\n'), column)).toBe(false)
|
|
// About 25 short words per column line; 13 lines' worth on one source line.
|
|
expect(fitsOnOnePage(Array.from({ length: 25 * (MAX_KEEP_TOGETHER_LINES + 1) }, () => 'ord').join(' '), column)).toBe(false)
|
|
})
|
|
|
|
it('counts the chunks a long token is broken into, not the source line', () => {
|
|
// 35 W per line is one source line but three rendered chunk lines.
|
|
const wide = Array.from({ length: 5 }, () => 'W'.repeat(35)).join('\n')
|
|
expect(fitsOnOnePage(wide, DESCRIPTION_COLUMN_PT)).toBe(false)
|
|
})
|
|
|
|
it('keeps the kept-together budget under a third of the page for any font', () => {
|
|
// Worst case: every line at 20pt (an uploaded font), plus row padding.
|
|
expect(MAX_KEEP_TOGETHER_LINES * 20 + 12).toBeLessThan(762 / 3)
|
|
})
|
|
|
|
it('a wide-glyph description in the bundled serif font is split instead of clipped', async () => {
|
|
const { prepareInvoiceFont } = await import('@/lib/invoices/pdf-fonts')
|
|
const branding = await prepareInvoiceFont(company, { fontFamily: 'Source Serif 4' } as never)
|
|
const description = 'Leverans\n' + Array.from({ length: 19 }, () => 'W'.repeat(35)).join('\n')
|
|
const items = [
|
|
makeItem({ description, discount_percent: 10 }),
|
|
makeItem({ sort_order: 1, id: 'item-1', description: 'Efterföljande rad', vat_rate: 12 }),
|
|
]
|
|
const pages = await layOut(InvoicePDF({ invoice: sentInvoice(), customer, items, company, branding }))
|
|
expectNothingPastThePageEdge(pages)
|
|
expect(pages.map(textOf).join('')).toContain('Efterföljande rad')
|
|
})
|
|
|
|
it('an 80-line description is split across pages instead of clipped', async () => {
|
|
const description = Array.from({ length: 80 }, (_, i) => `Specifikationsrad ${i + 1}`).join('\n')
|
|
const items = [makeItem({ description }), makeItem({ sort_order: 1, id: 'item-1', description: 'Efterföljande rad' })]
|
|
const pages = await layOut(InvoicePDF({ invoice: sentInvoice(), customer, items, company }))
|
|
expectNothingPastThePageEdge(pages)
|
|
const all = pages.map(textOf).join('')
|
|
expect(all).toContain('Specifikationsrad 80')
|
|
expect(all).toContain('Efterföljande rad')
|
|
})
|
|
|
|
it('80 lines of notes are split across pages instead of clipped', async () => {
|
|
const notes = Array.from({ length: 80 }, (_, i) => `Villkor ${i + 1}: leverans sker enligt avtal.`).join('\n')
|
|
const pages = await layOut(InvoicePDF({ invoice: { ...sentInvoice(), notes }, customer, items: [makeItem()], company }))
|
|
expectNothingPastThePageEdge(pages)
|
|
expect(pages.map(textOf).join('')).toContain('Villkor 80')
|
|
})
|
|
|
|
it('a free-text row is budgeted at its full width, not the description column', () => {
|
|
// 12 lines of 60 characters: fits the full width, not a 160pt column.
|
|
const text = Array.from({ length: MAX_KEEP_TOGETHER_LINES }, () => 'x'.repeat(60)).join('\n')
|
|
expect(fitsOnOnePage(text, FULL_WIDTH_BOX_PT)).toBe(true)
|
|
expect(fitsOnOnePage(text, DESCRIPTION_COLUMN_PT)).toBe(false)
|
|
const items = [makeItem({ description: text, line_type: 'text', quantity: 0, unit_price: 0 })]
|
|
const row = elements(InvoicePDF({ invoice: sentInvoice(), customer, items, company })).find(
|
|
(el) => el.props.wrap === false && containsText(el, 'x'.repeat(60)),
|
|
)
|
|
expect(row).toBeDefined()
|
|
})
|
|
|
|
it('the ROT/RUT box splits instead of clipping when its line breakdown is long', async () => {
|
|
const rutItem = (i: number, description: string) =>
|
|
makeItem({
|
|
sort_order: i,
|
|
id: `rut-${i}`,
|
|
description,
|
|
deduction_type: 'rut',
|
|
deduction_amount: 250,
|
|
work_type: 'STAD',
|
|
} as Partial<InvoiceItem>)
|
|
const invoice = { ...sentInvoice(), deduction_total: 250 }
|
|
const short = InvoicePDF({ invoice, customer, items: [rutItem(0, 'Städning')], company })
|
|
const shortBox = elements(short).find(
|
|
(el) => el.props.wrap !== undefined && containsText(el, 'Underlag för skattereduktion'),
|
|
)
|
|
expect(shortBox?.props.wrap).toBe(false)
|
|
|
|
const long = Array.from({ length: 40 }, (_, i) => rutItem(i, `Städning vecka ${i + 1}\nExtra fönsterputs`))
|
|
const pages = await layOut(InvoicePDF({ invoice, customer, items: long, company }))
|
|
expectNothingPastThePageEdge(pages)
|
|
expect(pages.map(textOf).join('')).toContain('Städning vecka 40')
|
|
})
|
|
|
|
it('a 3000-character description without line breaks is not clipped', async () => {
|
|
const description = Array.from({ length: 400 }, (_, i) => `ord${i + 1}`).join(' ')
|
|
const pages = await layOut(InvoicePDF({ invoice: sentInvoice(), customer, items: [makeItem({ description })], company }))
|
|
expectNothingPastThePageEdge(pages)
|
|
expect(pages.map(textOf).join('')).toContain('ord400')
|
|
})
|
|
})
|
|
|
|
describe('long tokens', () => {
|
|
it.each([
|
|
'https://app.testbrand.example/invoices/pay/7c1f0b7e-3d2a-4f1c-9a8e-2b6d5c4e3f21',
|
|
'AB-2026-09-KUND-1042-LEVERANS-SPECIFIKATION',
|
|
'fornamn.efternamn@ekonomi.exempelforetaget.se',
|
|
'Konsulttjänsteavtalsförlängningsdokumentationssammanställning',
|
|
])('stay inside the description column and on the page: %s', async (token) => {
|
|
const items = [makeItem({ description: `Leverans ${token}` })]
|
|
const pages = await layOut(InvoicePDF({ invoice: sentInvoice(), customer, items, company }))
|
|
expectEveryLineInsideItsBox(pages, 'Leverans')
|
|
// The whole token is printed, not dropped by the line breaker.
|
|
const printed = pages.map(textOf).join('')
|
|
expect(printed).toContain(token)
|
|
})
|
|
|
|
it('stay inside a text row and in the notes', async () => {
|
|
const url = 'https://www.skatteverket.se/foretag/moms/saljavarorochtjanster/omvandbetalningsskyldighet.4.html'
|
|
const items = [makeItem({ description: `Villkor: ${url}`, line_type: 'text', quantity: 0, unit_price: 0 })]
|
|
const invoice = { ...sentInvoice(), notes: `Läs mer: ${url}` }
|
|
const pages = await layOut(InvoicePDF({ invoice, customer, items, company }))
|
|
expectEveryLineInsideItsBox(pages, 'Villkor:')
|
|
expectEveryLineInsideItsBox(pages, 'Läs mer:')
|
|
const printed = pages.map(textOf).join('')
|
|
expect(printed.split(url).length - 1).toBe(2)
|
|
})
|
|
})
|
|
|
|
describe('page breaks', () => {
|
|
const tree = InvoicePDF({ invoice: sentInvoice(), customer, items: [makeItem()], company })
|
|
const all = elements(tree)
|
|
|
|
it('never splits a table row, the totals, the payment box or a notice box', () => {
|
|
const rowsWithText = all.filter((el) => containsText(el, 'Konsulttimmar') && el.props.wrap === false)
|
|
expect(rowsWithText.length).toBeGreaterThan(0)
|
|
expect(all.some((el) => el.props.wrap === false && containsText(el, 'Delsumma:'))).toBe(true)
|
|
expect(all.some((el) => el.props.wrap === false && containsText(el, 'Betalningsinformation'))).toBe(true)
|
|
})
|
|
|
|
it('keeps every section heading with the content below it', () => {
|
|
const headings = all.filter((el) => {
|
|
const style = styleOf(el)
|
|
return style.textTransform === 'uppercase' && style.letterSpacing === 0.5
|
|
})
|
|
expect(headings.length).toBeGreaterThanOrEqual(3)
|
|
for (const heading of headings) {
|
|
expect(heading.props.minPresenceAhead).toBe(HEADING_MIN_PRESENCE_AHEAD)
|
|
}
|
|
})
|
|
})
|
|
|
|
const ORDINARY_LONG_WORDS = [
|
|
'September',
|
|
'Konsulttimmar',
|
|
'Öresavrundning',
|
|
'Företagsförsäkring',
|
|
'Marknadsföringstjänster',
|
|
'Fastighetsskötsel',
|
|
'Löneadministration',
|
|
'Verksamhetsutveckling',
|
|
'Kvartalsrapportering',
|
|
'Redovisningskonsult',
|
|
'Momskompensationsansökan',
|
|
'Kommunikationsavdelningen',
|
|
'Sammanställningsdokumentet',
|
|
'Systemadministrationstjänst',
|
|
'Semesterlöneskuldsberäkning',
|
|
'Mervärdesskattedeklarationen',
|
|
]
|
|
|
|
describe('word wrapping', () => {
|
|
it('never hyphenates an ordinary word, however long', () => {
|
|
for (const word of ORDINARY_LONG_WORDS) {
|
|
expect(wrapDescriptionWords(word)).toEqual([word])
|
|
expect(wrapFullWidthWords(word)).toEqual([word])
|
|
}
|
|
})
|
|
|
|
it('gives a token wider than the column break opportunities after separators and where the column is full', () => {
|
|
const url = 'https://app.testbrand.example/invoices/pay/7c1f0b7e-3d2a-4f1c-9a8e-2b6d5c4e3f21'
|
|
const parts = wrapDescriptionWords(url)
|
|
expect(parts.join('')).toBe(url)
|
|
expect(parts.length).toBeGreaterThan(1)
|
|
for (const part of parts) expect(approxWidthPt(part)).toBeLessThanOrEqual(DESCRIPTION_COLUMN_PT)
|
|
expect(parts[0]).toBe('https:')
|
|
|
|
const compound = 'Konsulttjänsteavtalsförlängningsdokumentationssammanställning'
|
|
const chunks = wrapDescriptionWords(compound)
|
|
expect(chunks.join('')).toBe(compound)
|
|
expect(chunks.length).toBeGreaterThan(1)
|
|
for (const chunk of chunks) expect(approxWidthPt(chunk)).toBeLessThanOrEqual(DESCRIPTION_COLUMN_PT)
|
|
})
|
|
|
|
it('estimates from real Helvetica metrics and over-estimates unknown glyphs', () => {
|
|
// 'a' is 556 units: 5.56pt at 10pt, times the 10% margin.
|
|
expect(approxWidthPt('a')).toBeCloseTo(6.116, 3)
|
|
expect(approxWidthPt('æ')).toBeGreaterThan(approxWidthPt('a'))
|
|
// A glyph outside Helvetica counts wider than any Latin glyph.
|
|
expect(approxWidthPt('Ш')).toBeGreaterThan(approxWidthPt('W'))
|
|
})
|
|
|
|
it('breaks tokens of wide or unknown glyphs so they never overflow the column', async () => {
|
|
for (const token of ['æ'.repeat(24), 'Œ'.repeat(24), 'Ш'.repeat(24)]) {
|
|
expect(wrapDescriptionWords(token).length).toBeGreaterThan(1)
|
|
}
|
|
const items = [
|
|
makeItem({ description: `Ref ${'æ'.repeat(24)}`, discount_percent: 10 }),
|
|
makeItem({ sort_order: 1, id: 'item-1', description: 'Annan rad', vat_rate: 12 }),
|
|
]
|
|
const pages = await layOut(InvoicePDF({ invoice: sentInvoice(), customer, items, company }))
|
|
expectEveryLineInsideItsBox(pages, 'Ref ')
|
|
})
|
|
|
|
it('renders ordinary compounds whole in the narrowest description column', async () => {
|
|
const descriptions = [
|
|
'Timarvode augusti, uppdrag Fastighetsskötsel 2026',
|
|
'Utveckling av ny funktion samt Företagsförsäkring 2026',
|
|
'Konsultarvode enligt avtal för Marknadsföringstjänster',
|
|
'Timarvode augusti, uppdrag Verksamhetsutveckling',
|
|
'Möte om Momskompensationsansökan',
|
|
'Möte om Kommunikationsavdelningen',
|
|
'Möte om Sammanställningsdokumentet',
|
|
'Avser Systemadministrationstjänst 2026',
|
|
'Uppdrag: Mervärdesskattedeklarationen',
|
|
]
|
|
for (const description of descriptions) {
|
|
// Discount and a second VAT rate show every column, so the description
|
|
// column is at its narrowest.
|
|
const items = [
|
|
makeItem({ description, discount_percent: 10 }),
|
|
makeItem({ sort_order: 1, id: 'item-1', description: 'Annan rad', vat_rate: 12 }),
|
|
]
|
|
const pages = await layOut(InvoicePDF({ invoice: sentInvoice(), customer, items, company }))
|
|
const node = textNodes(pages[0]).find((n) => textOf(n) === description)
|
|
expect(node).toBeDefined()
|
|
for (const line of node!.lines ?? []) {
|
|
expect(line.string, description).not.toMatch(/-$/)
|
|
}
|
|
expectEveryLineInsideItsBox(pages, description.slice(0, 12))
|
|
}
|
|
})
|
|
|
|
it('applies to line descriptions, notes and the footer', () => {
|
|
const invoice = { ...sentInvoice(), notes: 'Tack för förtroendet' }
|
|
const tree = InvoicePDF({ invoice, customer, items: [makeItem()], company })
|
|
const withCallback = elements(tree).filter(
|
|
(el) => el.props.hyphenationCallback === wrapDescriptionWords || el.props.hyphenationCallback === wrapFullWidthWords,
|
|
)
|
|
expect(withCallback.some((el) => containsText(el, 'Konsulttimmar'))).toBe(true)
|
|
expect(withCallback.some((el) => containsText(el, 'Tack för förtroendet'))).toBe(true)
|
|
expect(withCallback.some((el) => containsText(el, 'Testbrand AB') || containsText(el, 'Org.nr'))).toBe(true)
|
|
})
|
|
})
|
|
|
|
describe('units', () => {
|
|
it('print in English on an English invoice and as stored on a Swedish one', () => {
|
|
const items = [makeItem({ unit: 'st' })]
|
|
const en = textLeaves(InvoicePDF({ invoice: sentInvoice(), customer, items, company, language: 'en' }))
|
|
const sv = textLeaves(InvoicePDF({ invoice: sentInvoice(), customer, items, company, language: 'sv' }))
|
|
expect(en).toContain('pcs')
|
|
expect(en).not.toContain('st')
|
|
expect(sv).toContain('st')
|
|
expect(sv).not.toContain('pcs')
|
|
})
|
|
})
|
|
|
|
describe('multi-line descriptions', () => {
|
|
it('keep their line breaks in the PDF text', () => {
|
|
const items = [makeItem({ description: 'Konsultation\nSeptember 2026' })]
|
|
const leaves = textLeaves(InvoicePDF({ invoice: sentInvoice(), customer, items, company }))
|
|
expect(leaves).toContain('Konsultation\nSeptember 2026')
|
|
})
|
|
})
|