@kreiseck/kasseneck-api 0.13.2 → 0.14.0

package/dist/esm/printing/qr-groesse.d.ts

@@ -10,26 +10,21 @@ import type { PosPaperSize, QrSize } from './escpos.js';
  * und ein 58-mm-Kopf hat 384. Zu breit heisst bei den meisten Geraeten nicht
  * "abgeschnitten", sondern **gar kein QR** — auf einem Pflichtbeleg der
  * schlechteste aller Ausgaenge. (Im Flutter-Zwilling war genau das der
- * belegte Fehler; dieses Paket druckt seit jeher mit vier Punkten und blieb
- * darum verschont. Die Regel ist trotzdem dieselbe: sie deckelt auch eine
- * ausdruecklich gewaehlte groessere Modulgroesse gegen den Papierrand ab.)
+ * belegte Fehler.) Die Regel deckelt darum auch eine ausdruecklich gewaehlte
+ * groessere Modulgroesse gegen den Papierrand ab.
  */
 /**
  * Wie gross die Module des Beleg-QR werden duerfen — ein **Deckel**, keine
  * Vorgabe: gedruckt wird immer die groesste Groesse, die noch aufs Papier
  * passt, hoechstens aber diese hier.
  *
- * `auto` und `klein` decken beide bei 4 — das ist kein Versehen. 4 ist der
- * Wert, den der native Weg dieses Pakets seit jeher druckt
- * (`qrCodeBytes(..., size ?? 4)`); ohne diesen Deckel bekaeme jedes Geraet ab
- * sofort ungefragt einen groesseren QR als gestern. `auto` heisst also
- * "rechne, aber aendere den Bestand nicht".
- *
- * **Abweichung zum Flutter-Zwilling, bewusst:** dort deckelt `auto` bei 6,
- * weil dort 6 der Bestandswert ist. Die Regel ist in beiden Paketen
- * dieselbe — "so gross wie moeglich, hoechstens der Bestandswert" —, nur der
- * Bestandswert unterscheidet sich. `mittel` (6) und `gross` (8) sind in
- * beiden Paketen gleich; sie waehlt ein Mensch.
+ * `auto` heisst "gerechnet, hoechstens 6 Punkte je Modul" — in diesem Paket
+ * und im Flutter-Zwilling dasselbe. Bis 0.13 deckelte `auto` hier bei 4 (dem
+ * alten Wert des nativen ESC/POS-Wegs), in Dart bei 6; derselbe Beleg kam
+ * dadurch je nach Paket verschieden gross aus dem Drucker. Einheitlich gilt
+ * jetzt 6: der Wert von Dart und vom Epson-Weg, und ein groesseres Modul
+ * liest sich besser. `klein` (4) druckt den QR so gross wie frueher `auto`;
+ * `mittel` (6) und `gross` (8) waehlt ein Mensch.
  */
 export type QrModulGroesse = 'auto' | 'klein' | 'mittel' | 'gross';
 /** Groesste Modulgroesse in Druckpunkten, die der jeweilige Deckel zulaesst. */
@@ -82,19 +77,29 @@ export declare const QR_DRUCK_PUNKTE: Readonly<Record<PosPaperSize, number>>;
 /**
  * Modulanzahl, die `nutzlast` bei Fehlerkorrektur **M** braucht.
  *
- * Warum M, obwohl der native Befehl mit L druckt: M braucht bei gleicher
- * Nutzlast gleich viele oder mehr Module als L. Wer mit M rechnet und mit L
- * druckt, druckt nie breiter als gerechnet — die Rechnung ist konservativ,
- * nie knapp. Umgekehrt waere sie eine Rechnung, die aufgeht, und ein Symbol,
- * das ueber den Papierrand laeuft. Dasselbe gilt fuer die Byte-Zaehlung: hier
- * zaehlt UTF-8 (wie im Flutter-Zwilling), waehrend `qrCodeBytes` die Nutzlast
- * als Latin-1 sendet — UTF-8 ist nie kuerzer, die Rechnung also nie zu klein.
+ * Alle Druckwege setzen den QR mit Fehlerkorrektur **M** (nativer
+ * ESC/POS-Befehl, ePOS `level_m`; das Raster fuer den Bildweg rechnet der
+ * Aufrufer ebenfalls mit M) — rechnet und druckt also mit M: gerechnete und
+ * gedruckte Modulanzahl stimmen ueberein, und der Anteil am Blatt
+ * (Bildschirm, PDF) ist genau der am Bon. Die Byte-Zaehlung ist
+ * konservativ: hier zaehlt UTF-8 (wie im Flutter-Zwilling), waehrend
+ * `qrCodeBytes` die Nutzlast als Latin-1 sendet — UTF-8 ist nie kuerzer, die
+ * Rechnung also nie zu klein.
  *
  * Wirft, wenn die Nutzlast in keine Version passt — wie `qrCodeBytes` bei zu
  * langem Inhalt. Ein still zurueckgegebenes "passt nicht" haette den
  * Datenfehler als Papierfehler getarnt.
  */
 export declare function qrModulAnzahl(nutzlast: string): number;
+/**
+ * Ob `nutzlast` in irgendeine QR-Version 1..40 bei Fehlerkorrektur M passt --
+ * dieselbe Tabelle wie `qrModulAnzahl`, aber ohne zu werfen.
+ *
+ * Fuer Aufrufer, denen ein zu langer Inhalt kein Programmierfehler ist,
+ * sondern ein Datenfehler, den sie selbst behandeln (das Beleg-Blatt: ohne
+ * QR weiterbauen statt den ganzen Zeichner mitzureissen).
+ */
+export declare function qrPasstInVersion(nutzlast: string): boolean;
 /**
  * Groesste Modulgroesse, mit der `moduleAnzahl` Module **samt Ruhezone** in
  * `papierbreitePunkte` passen, gedeckelt durch `groesse`.

package/dist/esm/printing/qr-groesse.js

@@ -1,6 +1,6 @@
 /** Groesste Modulgroesse in Druckpunkten, die der jeweilige Deckel zulaesst. */
 export const QR_MODUL_DECKEL = {
-    auto: 4,
+    auto: 6,
     klein: 4,
     mittel: 6,
     gross: 8,
@@ -43,13 +43,14 @@ const BYTE_KAPAZITAET_M = [
 /**
  * Modulanzahl, die `nutzlast` bei Fehlerkorrektur **M** braucht.
  *
- * Warum M, obwohl der native Befehl mit L druckt: M braucht bei gleicher
- * Nutzlast gleich viele oder mehr Module als L. Wer mit M rechnet und mit L
- * druckt, druckt nie breiter als gerechnet — die Rechnung ist konservativ,
- * nie knapp. Umgekehrt waere sie eine Rechnung, die aufgeht, und ein Symbol,
- * das ueber den Papierrand laeuft. Dasselbe gilt fuer die Byte-Zaehlung: hier
- * zaehlt UTF-8 (wie im Flutter-Zwilling), waehrend `qrCodeBytes` die Nutzlast
- * als Latin-1 sendet — UTF-8 ist nie kuerzer, die Rechnung also nie zu klein.
+ * Alle Druckwege setzen den QR mit Fehlerkorrektur **M** (nativer
+ * ESC/POS-Befehl, ePOS `level_m`; das Raster fuer den Bildweg rechnet der
+ * Aufrufer ebenfalls mit M) — rechnet und druckt also mit M: gerechnete und
+ * gedruckte Modulanzahl stimmen ueberein, und der Anteil am Blatt
+ * (Bildschirm, PDF) ist genau der am Bon. Die Byte-Zaehlung ist
+ * konservativ: hier zaehlt UTF-8 (wie im Flutter-Zwilling), waehrend
+ * `qrCodeBytes` die Nutzlast als Latin-1 sendet — UTF-8 ist nie kuerzer, die
+ * Rechnung also nie zu klein.
  *
  * Wirft, wenn die Nutzlast in keine Version passt — wie `qrCodeBytes` bei zu
  * langem Inhalt. Ein still zurueckgegebenes "passt nicht" haette den
@@ -63,6 +64,18 @@ export function qrModulAnzahl(nutzlast) {
     }
     throw new Error('QR-Inhalt ist zu lang');
 }
+/**
+ * Ob `nutzlast` in irgendeine QR-Version 1..40 bei Fehlerkorrektur M passt --
+ * dieselbe Tabelle wie `qrModulAnzahl`, aber ohne zu werfen.
+ *
+ * Fuer Aufrufer, denen ein zu langer Inhalt kein Programmierfehler ist,
+ * sondern ein Datenfehler, den sie selbst behandeln (das Beleg-Blatt: ohne
+ * QR weiterbauen statt den ganzen Zeichner mitzureissen).
+ */
+export function qrPasstInVersion(nutzlast) {
+    const laenge = new TextEncoder().encode(nutzlast).length;
+    return laenge <= BYTE_KAPAZITAET_M[BYTE_KAPAZITAET_M.length - 1];
+}
 /**
  * Groesste Modulgroesse, mit der `moduleAnzahl` Module **samt Ruhezone** in
  * `papierbreitePunkte` passen, gedeckelt durch `groesse`.

package/dist/esm/react/index.d.ts

@@ -1,5 +1,7 @@
 import { type ReactNode } from 'react';
 import type { ReceiptLayout } from '../receipt/layout.js';
+import { type BelegBlatt, type LogoStufe } from '../receipt/blatt.js';
+import type { QrModulGroesse } from '../printing/qr-groesse.js';
 /**
  * React-Adapter: zeichnet ein Beleg-Layout (siehe ../receipt/layout.ts).
  *
@@ -33,6 +35,11 @@ export interface ReceiptLayoutViewProps {
     /** Text auf dem verdeckten QR (Vorgabe „Antippen zum Anzeigen“). */
     qrVerdecktText?: string;
 }
+/**
+ * @deprecated Seit 0.14.0: [BelegBlattView] setzt den Beleg zeichengleich zu
+ * Bon und PDF (Raster, Logo, Marke). Diese Ansicht rechnet Spalten mit Flex
+ * und bricht darum anders um als das Papier.
+ */
 export declare function ReceiptLayoutView({ layout, className, renderQr, qrVerdeckt, qrVerdecktText }: ReceiptLayoutViewProps): ReactNode;
 /**
  * Verdeckter QR: weichgezeichnet und nicht scannbar, bis der Betrachter ihn
@@ -44,3 +51,49 @@ export declare function QrVerdeckt({ data, text, children }: {
     text?: string;
     children: ReactNode;
 }): ReactNode;
+export interface BelegBlattZeilenProps {
+    blatt: BelegBlatt;
+    /** Adresse des Firmenlogos; ohne sie bleibt der Logo-Block leer (Platz bleibt). */
+    logoUrl?: string;
+    /**
+     * Zeichnet den QR in seinen Kasten (`qrBlattAnteil`). Der Kasten schliesst
+     * die Ruhezone von 4 Modulen je Seite ein und setzt Fehlerkorrektur M
+     * voraus: das Symbol also mit Korrektur M und 4 Modulen Ruhezone zeichnen
+     * und den Kasten ganz ausfuellen -- dann ist ein Modul so gross wie am Bon.
+     */
+    renderQr?: (data: string) => ReactNode;
+    qrVerdeckt?: boolean;
+    qrVerdecktText?: string;
+    className?: string;
+}
+/**
+ * Das Blatt am Bildschirm -- Zeile fuer Zeile dieselben Zeichen wie am Bon und
+ * im PDF. Masse in `ch`: eine Zeichenbreite ist `1ch`, eine Zeile `2ch`, das
+ * Blatt `zeichen`ch breit. Der Verbraucher bestimmt nur Schrift (monospace,
+ * Vorgabe ueber `--keck-blatt-schrift`) und Schriftgroesse; alles andere steht
+ * im Blatt.
+ */
+export declare function BelegBlattZeilen({ blatt, logoUrl, renderQr, qrVerdeckt, qrVerdecktText, className }: BelegBlattZeilenProps): ReactNode;
+export interface BelegBlattViewProps extends Omit<BelegBlattZeilenProps, 'blatt' | 'logoUrl'> {
+    layout: ReceiptLayout;
+    zeichen?: number;
+    /** Firmenlogo und Stufe (`logoSkala`); das Pixelmass liest die Ansicht selbst. */
+    logo?: {
+        url: string;
+        stufe: LogoStufe;
+    } | null;
+    marke?: boolean;
+    /** Geraete-Einstellung fuer die QR-Modulgroesse; Vorgabe `auto` (hoechstens 6 Punkte je Modul) — wie die Druckwege. */
+    qrGroesse?: QrModulGroesse;
+}
+/**
+ * Laedt das Logo (fuer sein Pixelmass), baut das Blatt und zeichnet es. Bis
+ * das Bild geladen ist, fehlt der Logo-Block -- die Kasse laedt das Logo ohnehin
+ * vorab in den Browser-Cache.
+ *
+ * Ein Logo ueber [logoPixelZulaessig] (4096x4096px, dieselbe Grenze wie das
+ * Druck-Kit beim Rastern fuer den Bon) bleibt hier ebenso ohne Logo-Block --
+ * sonst zeigte der Bildschirm ein Logo, das nie gedruckt wird: Bildschirm und
+ * Bon zeigen dasselbe Logo.
+ */
+export declare function BelegBlattView({ layout, zeichen, logo, marke, qrGroesse, ...rest }: BelegBlattViewProps): ReactNode;

package/dist/esm/react/index.js

@@ -1,10 +1,16 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useState } from 'react';
+import { useEffect, useState } from 'react';
+import { belegBlatt, logoPixelZulaessig } from '../receipt/blatt.js';
 const AUSRICHTUNG = {
     left: 'left',
     center: 'center',
     right: 'right',
 };
+/**
+ * @deprecated Seit 0.14.0: [BelegBlattView] setzt den Beleg zeichengleich zu
+ * Bon und PDF (Raster, Logo, Marke). Diese Ansicht rechnet Spalten mit Flex
+ * und bricht darum anders um als das Papier.
+ */
 export function ReceiptLayoutView({ layout, className, renderQr, qrVerdeckt = false, qrVerdecktText }) {
     const klasse = className === undefined ? 'keck-receipt' : `keck-receipt ${className}`;
     return (_jsx("div", { className: klasse, "data-paper-size": layout.paperSize, children: layout.lines.map((zeile, index) => (_jsx(Zeile, { zeile: zeile, renderQr: renderQr, qrVerdeckt: qrVerdeckt, qrVerdecktText: qrVerdecktText }, index))) }));
@@ -55,3 +61,76 @@ function Zeile({ zeile, renderQr, qrVerdeckt, qrVerdecktText }) {
             }
     }
 }
+/**
+ * Das Blatt am Bildschirm -- Zeile fuer Zeile dieselben Zeichen wie am Bon und
+ * im PDF. Masse in `ch`: eine Zeichenbreite ist `1ch`, eine Zeile `2ch`, das
+ * Blatt `zeichen`ch breit. Der Verbraucher bestimmt nur Schrift (monospace,
+ * Vorgabe ueber `--keck-blatt-schrift`) und Schriftgroesse; alles andere steht
+ * im Blatt.
+ */
+export function BelegBlattZeilen({ blatt, logoUrl, renderQr, qrVerdeckt = false, qrVerdecktText, className }) {
+    const z = blatt.zeichen;
+    const klasse = className === undefined ? 'keck-blatt' : `keck-blatt ${className}`;
+    const blattStil = {
+        width: `${z}ch`,
+        fontFamily: 'var(--keck-blatt-schrift, "DM Mono", ui-monospace, Menlo, Consolas, monospace)',
+        fontVariantLigatures: 'none',
+    };
+    return (_jsx("div", { className: klasse, "data-zeichen": z, style: blattStil, children: blatt.bloecke.map((b, i) => {
+            switch (b.art) {
+                case 'zeile':
+                    return (_jsx("div", { className: "keck-blatt-zeile", style: { whiteSpace: 'pre', height: '2ch', lineHeight: '2ch', overflow: 'hidden', fontWeight: b.fett ? 'bold' : 'normal' }, children: b.text }, i));
+                case 'logo':
+                    return (_jsx("div", { className: "keck-blatt-logo", style: { height: `${b.hoeheZeilen * 2}ch`, display: 'flex', justifyContent: 'center' }, children: logoUrl === undefined ? null : (_jsx("img", { src: logoUrl, alt: "", "aria-hidden": "true", style: { width: `${b.breiteAnteil * z}ch`, height: `${b.hoeheZeilen * 2}ch`, objectFit: 'contain' } })) }, i));
+                case 'qr': {
+                    // Auch beim Anteil 0 (leer oder in keine Version passend) bekommt
+                    // `renderQr` die Nutzlast: die Oberflaeche muss sagen koennen, dass
+                    // der QR fehlt und ein Papierbeleg noetig ist. Bon und PDF lassen
+                    // den QR dann weg und melden es ueber `qrFehler`.
+                    const bild = renderQr !== undefined ? renderQr(b.nutzlast) : _jsx("div", { "data-qr": b.nutzlast, "aria-label": "RKSV-QR-Code" });
+                    return (_jsx("div", { className: "keck-blatt-qr", style: { display: 'flex', justifyContent: 'center' }, children: _jsx("div", { style: { width: `${b.breiteAnteil * z}ch`, aspectRatio: '1 / 1' }, children: qrVerdeckt ? _jsx(QrVerdeckt, { data: b.nutzlast, text: qrVerdecktText, children: bild }) : bild }) }, i));
+                }
+            }
+        }) }));
+}
+/**
+ * Laedt das Logo (fuer sein Pixelmass), baut das Blatt und zeichnet es. Bis
+ * das Bild geladen ist, fehlt der Logo-Block -- die Kasse laedt das Logo ohnehin
+ * vorab in den Browser-Cache.
+ *
+ * Ein Logo ueber [logoPixelZulaessig] (4096x4096px, dieselbe Grenze wie das
+ * Druck-Kit beim Rastern fuer den Bon) bleibt hier ebenso ohne Logo-Block --
+ * sonst zeigte der Bildschirm ein Logo, das nie gedruckt wird: Bildschirm und
+ * Bon zeigen dasselbe Logo.
+ */
+export function BelegBlattView({ layout, zeichen, logo, marke = false, qrGroesse, ...rest }) {
+    const [mass, setMass] = useState(null);
+    const url = logo?.url;
+    useEffect(() => {
+        if (url === undefined)
+            return undefined;
+        let aktiv = true;
+        const Bild = globalThis.Image;
+        if (Bild === undefined)
+            return undefined;
+        const bild = new Bild();
+        bild.onload = () => {
+            if (aktiv && logoPixelZulaessig(bild.naturalWidth, bild.naturalHeight))
+                setMass({ url, breite: bild.naturalWidth, hoehe: bild.naturalHeight });
+        };
+        bild.src = url;
+        return () => {
+            aktiv = false;
+        };
+    }, [url]);
+    const optionen = { marke };
+    if (zeichen !== undefined)
+        optionen.zeichen = zeichen;
+    if (qrGroesse !== undefined)
+        optionen.qrGroesse = qrGroesse;
+    const geladen = logo != null && mass !== null && mass.url === logo.url;
+    if (geladen)
+        optionen.logo = { stufe: logo.stufe, pxBreite: mass.breite, pxHoehe: mass.hoehe };
+    const blatt = belegBlatt(layout, optionen);
+    return geladen ? _jsx(BelegBlattZeilen, { blatt: blatt, logoUrl: logo.url, ...rest }) : _jsx(BelegBlattZeilen, { blatt: blatt, ...rest });
+}

package/dist/esm/receipt/bild.d.ts

@@ -0,0 +1,14 @@
+import type { RasterBild } from '../printing/escpos.js';
+import { type LogoMass } from './blatt.js';
+/**
+ * RGBA-Pixel (wie `ImageData.data` im Browser oder ein dekodiertes PNG in
+ * Node/Dart) -> einfarbiges Rasterbild in genau der Groesse, die das Blatt
+ * dem Logo gibt.
+ *
+ * Die Rechnung ist Vertrag und hat einen Dart-Zwilling (Golden
+ * `erwartet/logo-probe.raster32.txt`): Flaechenmittel je Druckpunkt,
+ * Durchsichtiges auf Papierweiss, Helligkeit nach BT.601, Floyd-Steinberg mit
+ * Schwelle 128. Die Reihenfolge der Rechenschritte nicht aendern -- beide
+ * Sprachen rechnen mit IEEE-Doubles und kommen nur so auf dieselben Punkte.
+ */
+export declare function logoRaster(rgba: ArrayLike<number>, pxBreite: number, pxHoehe: number, mass: LogoMass, zeichen: number): RasterBild;

package/dist/esm/receipt/bild.js

@@ -0,0 +1,62 @@
+import { logoRasterMass } from './blatt.js';
+/**
+ * RGBA-Pixel (wie `ImageData.data` im Browser oder ein dekodiertes PNG in
+ * Node/Dart) -> einfarbiges Rasterbild in genau der Groesse, die das Blatt
+ * dem Logo gibt.
+ *
+ * Die Rechnung ist Vertrag und hat einen Dart-Zwilling (Golden
+ * `erwartet/logo-probe.raster32.txt`): Flaechenmittel je Druckpunkt,
+ * Durchsichtiges auf Papierweiss, Helligkeit nach BT.601, Floyd-Steinberg mit
+ * Schwelle 128. Die Reihenfolge der Rechenschritte nicht aendern -- beide
+ * Sprachen rechnen mit IEEE-Doubles und kommen nur so auf dieselben Punkte.
+ */
+export function logoRaster(rgba, pxBreite, pxHoehe, mass, zeichen) {
+    if (!Number.isInteger(pxBreite) || !Number.isInteger(pxHoehe) || pxBreite < 1 || pxHoehe < 1 || rgba.length !== pxBreite * pxHoehe * 4) {
+        throw new Error('RGBA-Laenge passt nicht zum Pixelmass');
+    }
+    const { breite, hoehe } = logoRasterMass(mass, zeichen);
+    const grau = new Float64Array(breite * hoehe);
+    const sx = pxBreite / breite;
+    const sy = pxHoehe / hoehe;
+    for (let y = 0; y < hoehe; y++) {
+        const y0 = Math.floor(y * sy);
+        const y1 = Math.min(pxHoehe, Math.max(y0 + 1, Math.floor((y + 1) * sy)));
+        for (let x = 0; x < breite; x++) {
+            const x0 = Math.floor(x * sx);
+            const x1 = Math.min(pxBreite, Math.max(x0 + 1, Math.floor((x + 1) * sx)));
+            let summe = 0;
+            let anzahl = 0;
+            for (let py = y0; py < y1; py++) {
+                for (let px = x0; px < x1; px++) {
+                    const i = (py * pxBreite + px) * 4;
+                    const deckung = rgba[i + 3] / 255;
+                    const hell = 0.299 * rgba[i] + 0.587 * rgba[i + 1] + 0.114 * rgba[i + 2];
+                    summe += hell * deckung + 255 * (1 - deckung);
+                    anzahl += 1;
+                }
+            }
+            grau[y * breite + x] = anzahl === 0 ? 255 : summe / anzahl;
+        }
+    }
+    const punkte = new Uint8Array(breite * hoehe);
+    for (let y = 0; y < hoehe; y++) {
+        for (let x = 0; x < breite; x++) {
+            const i = y * breite + x;
+            const alt = grau[i];
+            const neu = alt < 128 ? 0 : 255;
+            if (neu === 0)
+                punkte[i] = 1;
+            const fehler = alt - neu;
+            if (x + 1 < breite)
+                grau[i + 1] = grau[i + 1] + (fehler * 7) / 16;
+            if (y + 1 < hoehe) {
+                if (x > 0)
+                    grau[i + breite - 1] = grau[i + breite - 1] + (fehler * 3) / 16;
+                grau[i + breite] = grau[i + breite] + (fehler * 5) / 16;
+                if (x + 1 < breite)
+                    grau[i + breite + 1] = grau[i + breite + 1] + fehler / 16;
+            }
+        }
+    }
+    return { breite, hoehe, punkte };
+}

package/dist/esm/receipt/blatt.d.ts

@@ -0,0 +1,107 @@
+import type { PosPaperSize } from '../printing/escpos.js';
+import { type QrModulGroesse } from '../printing/index.js';
+import type { ReceiptLayout } from './layout.js';
+/**
+ * Das Beleg-Blatt: die vollstaendige Folge dessen, was auf dem Papier steht --
+ * Rasterzeilen, Firmenlogo, QR und Marke, mit Groessen als Anteil der
+ * Blattbreite und in Zeilen.
+ *
+ * Bis 0.13 setzte jeder Zeichner das Raster selbst zusammen und entschied
+ * Logo-Ort, Logo-Groesse, Rahmen und QR-Groesse fuer sich. Heraus kamen
+ * fuenf verschiedene Belege (Panel: Logo ueber dem Testkassen-Rahmen, PDF:
+ * Logo auf dem Rahmen, App: kein Logo). Hier steht das jetzt einmal.
+ *
+ * Masseinheit ist der Druckkopf (Epson Font A, 203 dpi): ein Zeichen ist 12
+ * Punkte breit, eine Zeile 24 Punkte hoch. Am Bildschirm ist eine Zeile `2ch`,
+ * im PDF zwei Zeichenbreiten.
+ */
+export type LogoStufe = 'S' | 'M' | 'L' | 'XL';
+/** Kasten je Stufe: Anteil der Blattbreite und Hoehe in Zeilen (Werte der Web-Kasse). */
+export declare const LOGO_STUFEN: Readonly<Record<LogoStufe, {
+    readonly breiteAnteil: number;
+    readonly hoeheZeilen: number;
+}>>;
+export declare const PUNKTE_JE_ZEICHEN = 12;
+export declare const PUNKTE_JE_ZEILE = 24;
+/** Die Marke am Belegende (Konto-Flag `kreiseck_logo`) -- Text, damit jeder Weg sie gleich setzt. */
+export declare const MARKE_TEXT = "erstellt mit Kasseneck";
+export interface BlattLogo {
+    stufe: LogoStufe;
+    /** Pixelmass des Originalbilds -- ohne das laesst sich nicht einpassen. */
+    pxBreite: number;
+    pxHoehe: number;
+}
+export interface LogoMass {
+    /** Anteil der Blattbreite (0..1). */
+    breiteAnteil: number;
+    /** Hoehe in Zeilen (nicht ganzzahlig). */
+    hoeheZeilen: number;
+}
+export type BlattBlock = {
+    readonly art: 'zeile';
+    readonly text: string;
+    readonly fett: boolean;
+    readonly leer: boolean;
+} | {
+    readonly art: 'logo';
+    readonly breiteAnteil: number;
+    readonly hoeheZeilen: number;
+} | {
+    readonly art: 'qr';
+    readonly nutzlast: string;
+    readonly breiteAnteil: number;
+};
+export interface BelegBlatt {
+    readonly zeichen: number;
+    readonly bloecke: readonly BlattBlock[];
+}
+export interface BelegBlattOptionen {
+    /** Zeichen je Zeile; Vorgabe nach `layout.paperSize` (32/48). */
+    zeichen?: number;
+    /** Firmenlogo; ohne Angabe kein Logo-Block. */
+    logo?: BlattLogo | null;
+    /** "erstellt mit Kasseneck" am Ende. */
+    marke?: boolean;
+    /** Geraete-Einstellung fuer die QR-Modulgroesse; Vorgabe `auto` (hoechstens 6 Punkte je Modul) — wie die Druckwege. */
+    qrGroesse?: QrModulGroesse;
+}
+/**
+ * 32 Zeichen sind 58 mm, 48 sind 80 mm; andere Breiten behalten das Papier des
+ * Layouts. Der QR-Anteil (`qrBlattAnteil`) wird dann fuer die Kopfbreite
+ * DIESES Papiers gerechnet, nicht fuer die gewaehlte Zeichenzahl.
+ */
+export declare function papierFuerZeichen(zeichen: number, vorgabe: PosPaperSize): PosPaperSize;
+/**
+ * Obergrenze der Logo-Pixel, die der Bildschirm noch anzeigen darf -- exakt
+ * dieselbe Grenze wie im Druck-Kit (`LOGO_PIXEL_MAX` in `druck-logo.ts`):
+ * Bon und ePOS lehnen ein Logo ueber 4096x4096px schon beim Rastern ab (ein
+ * grosses Bild blockiert das Geraet). Ohne diese Grenze wuerde der
+ * Bildschirm ein Logo zeigen, das der Bon nie druckt -- Bildschirm und
+ * Papier waeren sich uneins, genau das soll das Beleg-Blatt verhindern.
+ */
+export declare const LOGO_PIXEL_MAX = 4096;
+/** Reine Pruefung, ob ein Logo dieser Pixelmasse noch angezeigt/gedruckt werden darf. */
+export declare function logoPixelZulaessig(breite: number, hoehe: number): boolean;
+/**
+ * Das Logo in den Kasten seiner Stufe einpassen -- **nie hochrechnen**: ein
+ * Bildpixel wird hoechstens ein Druckpunkt. Ein kleines Logo bleibt klein,
+ * statt am Bon verwaschen zu werden (so hielten es PDF und Web-Kasse schon).
+ */
+export declare function logoMass(logo: BlattLogo, zeichen: number): LogoMass;
+/** Das Mass in ganzen Druckpunkten -- so gross muss das Rasterbild fuer den Bon sein. */
+export declare function logoRasterMass(mass: LogoMass, zeichen: number): {
+    breite: number;
+    hoehe: number;
+};
+/**
+ * Anteil der Blattbreite, den der QR am Drucker einnimmt -- dieselbe Rechnung
+ * wie der Druckweg (nativ, sonst der Bildweg). Bildschirm und PDF zeigen den
+ * QR in genau dieser Groesse. Leere Nutzlast: 0 (kein Symbol).
+ *
+ * Der Kasten **schliesst die Ruhezone von 4 Modulen je Seite ein** und setzt
+ * Fehlerkorrektur M voraus. Ein Zeichner (`renderQr`, PDF) muss das Symbol
+ * darum mit Fehlerkorrektur M und einer Ruhezone von 4 Modulen zeichnen, die
+ * den Kasten ganz ausfuellt -- sonst stimmt die Modulgroesse nicht mit dem Bon.
+ */
+export declare function qrBlattAnteil(nutzlast: string, papier: PosPaperSize, groesse?: QrModulGroesse): number;
+export declare function belegBlatt(layout: ReceiptLayout, optionen?: BelegBlattOptionen): BelegBlatt;

package/dist/esm/receipt/blatt.js

@@ -0,0 +1,128 @@
+import { QR_DRUCK_PUNKTE, QR_RUHEZONE_MODULE, qrGroesseFuer, qrPasstInVersion, qrRasterPunkte, } from '../printing/index.js';
+import { renderReceiptGrid, ZEICHEN_JE_PAPIER } from './grid.js';
+/** Kasten je Stufe: Anteil der Blattbreite und Hoehe in Zeilen (Werte der Web-Kasse). */
+export const LOGO_STUFEN = {
+    S: { breiteAnteil: 0.42, hoeheZeilen: 5 },
+    M: { breiteAnteil: 0.62, hoeheZeilen: 8 },
+    L: { breiteAnteil: 0.8, hoeheZeilen: 12 },
+    XL: { breiteAnteil: 0.94, hoeheZeilen: 16 },
+};
+export const PUNKTE_JE_ZEICHEN = 12;
+export const PUNKTE_JE_ZEILE = 24;
+/** Die Marke am Belegende (Konto-Flag `kreiseck_logo`) -- Text, damit jeder Weg sie gleich setzt. */
+export const MARKE_TEXT = 'erstellt mit Kasseneck';
+/**
+ * 32 Zeichen sind 58 mm, 48 sind 80 mm; andere Breiten behalten das Papier des
+ * Layouts. Der QR-Anteil (`qrBlattAnteil`) wird dann fuer die Kopfbreite
+ * DIESES Papiers gerechnet, nicht fuer die gewaehlte Zeichenzahl.
+ */
+export function papierFuerZeichen(zeichen, vorgabe) {
+    if (zeichen === ZEICHEN_JE_PAPIER.mm58)
+        return 'mm58';
+    if (zeichen === ZEICHEN_JE_PAPIER.mm80)
+        return 'mm80';
+    return vorgabe;
+}
+/**
+ * Obergrenze der Logo-Pixel, die der Bildschirm noch anzeigen darf -- exakt
+ * dieselbe Grenze wie im Druck-Kit (`LOGO_PIXEL_MAX` in `druck-logo.ts`):
+ * Bon und ePOS lehnen ein Logo ueber 4096x4096px schon beim Rastern ab (ein
+ * grosses Bild blockiert das Geraet). Ohne diese Grenze wuerde der
+ * Bildschirm ein Logo zeigen, das der Bon nie druckt -- Bildschirm und
+ * Papier waeren sich uneins, genau das soll das Beleg-Blatt verhindern.
+ */
+export const LOGO_PIXEL_MAX = 4096;
+/** Reine Pruefung, ob ein Logo dieser Pixelmasse noch angezeigt/gedruckt werden darf. */
+export function logoPixelZulaessig(breite, hoehe) {
+    return breite > 0 && hoehe > 0 && breite <= LOGO_PIXEL_MAX && hoehe <= LOGO_PIXEL_MAX;
+}
+/**
+ * Das Logo in den Kasten seiner Stufe einpassen -- **nie hochrechnen**: ein
+ * Bildpixel wird hoechstens ein Druckpunkt. Ein kleines Logo bleibt klein,
+ * statt am Bon verwaschen zu werden (so hielten es PDF und Web-Kasse schon).
+ */
+export function logoMass(logo, zeichen) {
+    if (!(logo.pxBreite > 0) || !(logo.pxHoehe > 0))
+        throw new Error('Logo ohne Pixelmass');
+    const stufe = LOGO_STUFEN[logo.stufe];
+    if (stufe === undefined)
+        throw new Error(`Unbekannte Logo-Stufe: ${String(logo.stufe)}`);
+    const blattPunkte = zeichen * PUNKTE_JE_ZEICHEN;
+    const faktor = Math.min((stufe.breiteAnteil * blattPunkte) / logo.pxBreite, (stufe.hoeheZeilen * PUNKTE_JE_ZEILE) / logo.pxHoehe, 1);
+    return {
+        breiteAnteil: (logo.pxBreite * faktor) / blattPunkte,
+        hoeheZeilen: (logo.pxHoehe * faktor) / PUNKTE_JE_ZEILE,
+    };
+}
+/** Das Mass in ganzen Druckpunkten -- so gross muss das Rasterbild fuer den Bon sein. */
+export function logoRasterMass(mass, zeichen) {
+    return {
+        breite: Math.max(1, Math.round(mass.breiteAnteil * zeichen * PUNKTE_JE_ZEICHEN)),
+        hoehe: Math.max(1, Math.round(mass.hoeheZeilen * PUNKTE_JE_ZEILE)),
+    };
+}
+/**
+ * Anteil der Blattbreite, den der QR am Drucker einnimmt -- dieselbe Rechnung
+ * wie der Druckweg (nativ, sonst der Bildweg). Bildschirm und PDF zeigen den
+ * QR in genau dieser Groesse. Leere Nutzlast: 0 (kein Symbol).
+ *
+ * Der Kasten **schliesst die Ruhezone von 4 Modulen je Seite ein** und setzt
+ * Fehlerkorrektur M voraus. Ein Zeichner (`renderQr`, PDF) muss das Symbol
+ * darum mit Fehlerkorrektur M und einer Ruhezone von 4 Modulen zeichnen, die
+ * den Kasten ganz ausfuellt -- sonst stimmt die Modulgroesse nicht mit dem Bon.
+ */
+export function qrBlattAnteil(nutzlast, papier, groesse = 'auto') {
+    if (nutzlast === '')
+        return 0;
+    // Ein Inhalt, der in keine QR-Version passt (Fehlerkorrektur M, hoechstens
+    // 2331 Byte), wuerde hier `qrGroesseFuer` -> `qrModulAnzahl` zum Werfen
+    // bringen -- und riss damit jeden Zeichner mit, der das Blatt baut
+    // (Bildschirm, Bon, PDF). 0, wie bei leerer Nutzlast: der Beleg steht ohne
+    // QR, statt gar nicht zu stehen. `qrModulAnzahl` selbst wirft weiter -- wer
+    // es ausserhalb des Blatts aufruft, soll den Fehler sehen.
+    if (!qrPasstInVersion(nutzlast))
+        return 0;
+    const papierPunkte = QR_DRUCK_PUNKTE[papier];
+    const mass = qrGroesseFuer({ nutzlast, papierbreitePunkte: papierPunkte, groesse });
+    if (mass.passt)
+        return mass.breitePunkte / papierPunkte;
+    return ((mass.module + 2 * QR_RUHEZONE_MODULE) * qrRasterPunkte(papier, mass.module, { groesse })) / papierPunkte;
+}
+function zentriert(text, zeichen) {
+    const t = text.length > zeichen ? text.slice(0, zeichen) : text;
+    const links = Math.floor((zeichen - t.length) / 2);
+    return ' '.repeat(links) + t + ' '.repeat(zeichen - t.length - links);
+}
+export function belegBlatt(layout, optionen = {}) {
+    const grid = renderReceiptGrid(layout, optionen.zeichen === undefined ? {} : { zeichen: optionen.zeichen });
+    const zeichen = grid.zeichen;
+    const papier = papierFuerZeichen(zeichen, layout.paperSize);
+    const qrGroesse = optionen.qrGroesse ?? 'auto';
+    const leerzeile = { art: 'zeile', text: ' '.repeat(zeichen), fett: false, leer: true };
+    const block = (z) => z.kind === 'qr'
+        ? { art: 'qr', nutzlast: z.qr ?? '', breiteAnteil: qrBlattAnteil(z.qr ?? '', papier, qrGroesse) }
+        : { art: 'zeile', text: z.text, fett: z.bold, leer: z.kind === 'space' };
+    const bloecke = [];
+    let i = 0;
+    if (optionen.logo) {
+        // Fuehrende Aufdrucke (Testkasse, Testsignatur) bleiben ganz oben: wer den
+        // Beleg sieht, sieht zuerst, dass er nicht gilt.
+        while (i < grid.lines.length && grid.lines[i].kind === 'banner') {
+            bloecke.push(block(grid.lines[i]));
+            i += 1;
+        }
+        // Die Leerzeilen gehoeren zum Vertrag: kein Zeichner kann das Logo an einen
+        // Rahmen oder an den Firmennamen kleben.
+        if (i > 0)
+            bloecke.push(leerzeile);
+        bloecke.push({ art: 'logo', ...logoMass(optionen.logo, zeichen) });
+        bloecke.push(leerzeile);
+    }
+    for (; i < grid.lines.length; i += 1)
+        bloecke.push(block(grid.lines[i]));
+    if (optionen.marke === true) {
+        bloecke.push(leerzeile);
+        bloecke.push({ art: 'zeile', text: zentriert(MARKE_TEXT, zeichen), fett: false, leer: false });
+    }
+    return { zeichen, bloecke };
+}