@kreiseck/kasseneck-api 0.13.2 → 0.14.0

package/dist/cjs/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/cjs/react/index.js

@@ -2,13 +2,21 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ReceiptLayoutView = ReceiptLayoutView;
 exports.QrVerdeckt = QrVerdeckt;
+exports.BelegBlattZeilen = BelegBlattZeilen;
+exports.BelegBlattView = BelegBlattView;
 const jsx_runtime_1 = require("react/jsx-runtime");
 const react_1 = require("react");
+const blatt_js_1 = require("../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.
+ */
 function ReceiptLayoutView({ layout, className, renderQr, qrVerdeckt = false, qrVerdecktText }) {
     const klasse = className === undefined ? 'keck-receipt' : `keck-receipt ${className}`;
     return ((0, jsx_runtime_1.jsx)("div", { className: klasse, "data-paper-size": layout.paperSize, children: layout.lines.map((zeile, index) => ((0, jsx_runtime_1.jsx)(Zeile, { zeile: zeile, renderQr: renderQr, qrVerdeckt: qrVerdeckt, qrVerdecktText: qrVerdecktText }, index))) }));
@@ -59,3 +67,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.
+ */
+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 ((0, jsx_runtime_1.jsx)("div", { className: klasse, "data-zeichen": z, style: blattStil, children: blatt.bloecke.map((b, i) => {
+            switch (b.art) {
+                case 'zeile':
+                    return ((0, jsx_runtime_1.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 ((0, jsx_runtime_1.jsx)("div", { className: "keck-blatt-logo", style: { height: `${b.hoeheZeilen * 2}ch`, display: 'flex', justifyContent: 'center' }, children: logoUrl === undefined ? null : ((0, jsx_runtime_1.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) : (0, jsx_runtime_1.jsx)("div", { "data-qr": b.nutzlast, "aria-label": "RKSV-QR-Code" });
+                    return ((0, jsx_runtime_1.jsx)("div", { className: "keck-blatt-qr", style: { display: 'flex', justifyContent: 'center' }, children: (0, jsx_runtime_1.jsx)("div", { style: { width: `${b.breiteAnteil * z}ch`, aspectRatio: '1 / 1' }, children: qrVerdeckt ? (0, jsx_runtime_1.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.
+ */
+function BelegBlattView({ layout, zeichen, logo, marke = false, qrGroesse, ...rest }) {
+    const [mass, setMass] = (0, react_1.useState)(null);
+    const url = logo?.url;
+    (0, react_1.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 && (0, blatt_js_1.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 = (0, blatt_js_1.belegBlatt)(layout, optionen);
+    return geladen ? (0, jsx_runtime_1.jsx)(BelegBlattZeilen, { blatt: blatt, logoUrl: logo.url, ...rest }) : (0, jsx_runtime_1.jsx)(BelegBlattZeilen, { blatt: blatt, ...rest });
+}

package/dist/cjs/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/cjs/receipt/bild.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logoRaster = logoRaster;
+const blatt_js_1 = require("./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.
+ */
+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 } = (0, blatt_js_1.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/cjs/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/cjs/receipt/blatt.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LOGO_PIXEL_MAX = exports.MARKE_TEXT = exports.PUNKTE_JE_ZEILE = exports.PUNKTE_JE_ZEICHEN = exports.LOGO_STUFEN = void 0;
+exports.papierFuerZeichen = papierFuerZeichen;
+exports.logoPixelZulaessig = logoPixelZulaessig;
+exports.logoMass = logoMass;
+exports.logoRasterMass = logoRasterMass;
+exports.qrBlattAnteil = qrBlattAnteil;
+exports.belegBlatt = belegBlatt;
+const index_js_1 = require("../printing/index.js");
+const grid_js_1 = require("./grid.js");
+/** Kasten je Stufe: Anteil der Blattbreite und Hoehe in Zeilen (Werte der Web-Kasse). */
+exports.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 },
+};
+exports.PUNKTE_JE_ZEICHEN = 12;
+exports.PUNKTE_JE_ZEILE = 24;
+/** Die Marke am Belegende (Konto-Flag `kreiseck_logo`) -- Text, damit jeder Weg sie gleich setzt. */
+exports.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.
+ */
+function papierFuerZeichen(zeichen, vorgabe) {
+    if (zeichen === grid_js_1.ZEICHEN_JE_PAPIER.mm58)
+        return 'mm58';
+    if (zeichen === grid_js_1.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.
+ */
+exports.LOGO_PIXEL_MAX = 4096;
+/** Reine Pruefung, ob ein Logo dieser Pixelmasse noch angezeigt/gedruckt werden darf. */
+function logoPixelZulaessig(breite, hoehe) {
+    return breite > 0 && hoehe > 0 && breite <= exports.LOGO_PIXEL_MAX && hoehe <= exports.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).
+ */
+function logoMass(logo, zeichen) {
+    if (!(logo.pxBreite > 0) || !(logo.pxHoehe > 0))
+        throw new Error('Logo ohne Pixelmass');
+    const stufe = exports.LOGO_STUFEN[logo.stufe];
+    if (stufe === undefined)
+        throw new Error(`Unbekannte Logo-Stufe: ${String(logo.stufe)}`);
+    const blattPunkte = zeichen * exports.PUNKTE_JE_ZEICHEN;
+    const faktor = Math.min((stufe.breiteAnteil * blattPunkte) / logo.pxBreite, (stufe.hoeheZeilen * exports.PUNKTE_JE_ZEILE) / logo.pxHoehe, 1);
+    return {
+        breiteAnteil: (logo.pxBreite * faktor) / blattPunkte,
+        hoeheZeilen: (logo.pxHoehe * faktor) / exports.PUNKTE_JE_ZEILE,
+    };
+}
+/** Das Mass in ganzen Druckpunkten -- so gross muss das Rasterbild fuer den Bon sein. */
+function logoRasterMass(mass, zeichen) {
+    return {
+        breite: Math.max(1, Math.round(mass.breiteAnteil * zeichen * exports.PUNKTE_JE_ZEICHEN)),
+        hoehe: Math.max(1, Math.round(mass.hoeheZeilen * exports.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.
+ */
+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 (!(0, index_js_1.qrPasstInVersion)(nutzlast))
+        return 0;
+    const papierPunkte = index_js_1.QR_DRUCK_PUNKTE[papier];
+    const mass = (0, index_js_1.qrGroesseFuer)({ nutzlast, papierbreitePunkte: papierPunkte, groesse });
+    if (mass.passt)
+        return mass.breitePunkte / papierPunkte;
+    return ((mass.module + 2 * index_js_1.QR_RUHEZONE_MODULE) * (0, index_js_1.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);
+}
+function belegBlatt(layout, optionen = {}) {
+    const grid = (0, grid_js_1.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(exports.MARKE_TEXT, zeichen), fett: false, leer: false });
+    }
+    return { zeichen, bloecke };
+}

package/dist/cjs/receipt/epos.d.ts

@@ -1,11 +1,12 @@
 import type { ReceiptLayout } from './layout.js';
 import type { PosPaperSize } from '../printing/escpos.js';
-import { type QrModulGroesse } from '../printing/index.js';
+import { type QrModulGroesse, type RasterBild } from '../printing/index.js';
+import { type DruckLogo } from './layout-escpos.js';
 /**
  * ePOS-Print XML (Epson TM-Drucker: Server Direct Print, ePOS-Print ueber
  * HTTP) -- **aus dem Zeichenraster**: jede Rasterzeile wird eine <text>-Zeile
- * mit exakt N Zeichen und Zeilenumbruch, Aufdrucke doppelt hoch (Warnungen
- * invers), QR als <symbol>, Leerraum als <feed>, am Ende Schnitt. Kein
+ * mit exakt N Zeichen und Zeilenumbruch, Aufdrucke als Rahmen aus
+ * Rasterzeilen, QR als <symbol>, Leerraum als <feed>, am Ende Schnitt. Kein
  * eigenes Setzen -- was Bildschirm, ESC/POS und PDF zeigen, druckt der Epson
  * Zeile fuer Zeile genauso.
  *
@@ -22,16 +23,20 @@ export interface EposPrintXmlOptions {
      */
     qrBreite?: number;
     /**
-     * Deckel fuer die gerechnete QR-Modulgroesse; Vorgabe `mittel`.
+     * Deckel fuer die gerechnete QR-Modulgroesse; Vorgabe `auto` (hoechstens 6
+     * Punkte je Modul) -- wie ESC/POS, Blatt und der Flutter-Zwilling.
      *
-     * Warum `mittel` und nicht `auto`: `auto` deckelt beim Bestandswert des
-     * **ESC/POS**-Befehls dieses Pakets (4), dieser Weg druckt aber seit jeher
-     * mit 6. Die Vorgabe nennt den Bestandswert dieses Wegs also ausdruecklich,
-     * damit ohne Wahl kein Byte anders herauskommt.
+     * Bis 0.13 stand hier `mittel`, weil `auto` damals beim ESC/POS-Wert 4
+     * deckelte und dieser Weg seit jeher mit 6 druckt. Seit `auto` ueberall 6
+     * heisst, ist das derselbe Wert: ohne Wahl kommt kein Byte anders heraus.
      */
     qrGroesse?: QrModulGroesse;
     /** Papierschnitt am Ende, Vorgabe true. */
     cut?: boolean;
+    /** Firmenlogo; ohne Angabe kein Logo. */
+    logo?: DruckLogo | null;
+    /** "erstellt mit Kasseneck" am Ende. */
+    marke?: boolean;
 }
 /**
  * Das XML **samt** dem, was dem QR unterwegs zugestossen ist -- dieselbe
@@ -45,6 +50,8 @@ export interface EposPrintErgebnis {
     qrAusweich: string | null;
 }
 export declare function eposXmlEscape(text: string): string;
+/** Ein Rasterbild als ePOS-`<image>` (einfarbig, Punktmass, Rasterzeilen Base64). */
+export declare function eposBildXml(bild: RasterBild): string;
 /** Nur das XML; wer die QR-Meldungen braucht, nimmt [eposPrintXmlErgebnis]. */
 export declare function eposPrintXml(layout: ReceiptLayout, options?: EposPrintXmlOptions): string;
 /**
@@ -77,6 +84,10 @@ export interface EposDirectOptions {
     qrBreite?: number;
     /** Deckel fuer die gerechnete QR-Modulgroesse; siehe [EposPrintXmlOptions.qrGroesse]. */
     qrGroesse?: QrModulGroesse;
+    /** Firmenlogo; ohne Angabe kein Logo. */
+    logo?: DruckLogo | null;
+    /** "erstellt mit Kasseneck" am Ende. */
+    marke?: boolean;
     timeoutMs?: number;
 }
 export interface EposResponse {

package/dist/cjs/receipt/epos.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EposConnectionError = void 0;
 exports.eposXmlEscape = eposXmlEscape;
+exports.eposBildXml = eposBildXml;
 exports.eposPrintXml = eposPrintXml;
 exports.eposPrintXmlErgebnis = eposPrintXmlErgebnis;
 exports.eposServiceUrl = eposServiceUrl;
@@ -11,9 +12,14 @@ exports.eposDirectPrint = eposDirectPrint;
 exports.eposDirectStatus = eposDirectStatus;
 const index_js_1 = require("../printing/index.js");
 const grid_js_1 = require("./grid.js");
+const layout_escpos_js_1 = require("./layout-escpos.js");
 function eposXmlEscape(text) {
     return text.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;').replace(/'/g, '&apos;');
 }
+/** Ein Rasterbild als ePOS-`<image>` (einfarbig, Punktmass, Rasterzeilen Base64). */
+function eposBildXml(bild) {
+    return `<image width="${bild.breite}" height="${bild.hoehe}" color="color_1" mode="mono">${(0, index_js_1.rasterZeilenBase64)(bild)}</image>`;
+}
 const NS = 'http://www.epson-pos.com/schemas/2011/03/epos-print';
 /** Nur das XML; wer die QR-Meldungen braucht, nimmt [eposPrintXmlErgebnis]. */
 function eposPrintXml(layout, options = {}) {
@@ -30,8 +36,9 @@ function eposPrintXml(layout, options = {}) {
  * laesst es weg; genau daran fehlte am echten Beleg der QR.
  */
 function eposPrintXmlErgebnis(layout, options = {}) {
-    const grid = (0, grid_js_1.renderReceiptGrid)(layout, { zeichen: options.zeichen ?? grid_js_1.ZEICHEN_JE_PAPIER[layout.paperSize] });
-    const deckel = options.qrGroesse ?? 'mittel';
+    const zeichen = options.zeichen ?? grid_js_1.ZEICHEN_JE_PAPIER[layout.paperSize];
+    const deckel = options.qrGroesse ?? 'auto';
+    const blatt = (0, layout_escpos_js_1.blattFuerDruck)(layout, { zeichen, logo: options.logo, marke: options.marke, qrGroesse: deckel });
     const fest = options.qrBreite === undefined
         ? null
         : Math.min(16, Math.max(3, Math.floor(options.qrBreite)));
@@ -50,6 +57,12 @@ function eposPrintXmlErgebnis(layout, options = {}) {
             return fest;
         if (nutzlast === '')
             return index_js_1.QR_MODUL_DECKEL[deckel];
+        // Passt der Inhalt in keine QR-Version, gibt es kein Symbol, das der
+        // Drucker setzen koennte -- wie beim Blatt (Anteil 0) geht der Beleg ohne QR.
+        if (!(0, index_js_1.qrPasstInVersion)(nutzlast)) {
+            qrFehler = 'QR-Inhalt passt in keine QR-Version -- Beleg ohne QR';
+            return null;
+        }
         const mass = (0, index_js_1.qrGroesseFuer)({
             nutzlast,
             papierbreitePunkte: index_js_1.QR_DRUCK_PUNKTE[layout.paperSize],
@@ -74,32 +87,34 @@ function eposPrintXmlErgebnis(layout, options = {}) {
     out.push('<text font="font_a"/>');
     out.push('<text align="left"/>');
     out.push('<text width="1" height="1" reverse="false" em="false"/>');
-    for (const z of grid.lines) {
-        switch (z.kind) {
-            case 'space':
-                out.push('<feed line="1"/>');
+    for (const block of blatt.bloecke) {
+        switch (block.art) {
+            case 'zeile':
+                if (block.leer)
+                    out.push('<feed line="1"/>');
+                else if (block.fett) {
+                    out.push(`<text em="true">${eposXmlEscape(block.text)}&#10;</text>`);
+                    out.push('<text em="false"/>');
+                }
+                else
+                    out.push(`<text>${eposXmlEscape(block.text)}&#10;</text>`);
+                break;
+            case 'logo':
+                if (options.logo) {
+                    out.push('<text align="center"/>');
+                    out.push(eposBildXml(options.logo.raster));
+                    out.push('<text align="left"/>');
+                }
                 break;
             case 'qr': {
-                const breite = qrBreiteFuer(z.qr ?? '');
+                const breite = qrBreiteFuer(block.nutzlast);
                 if (breite === null)
                     break;
                 out.push('<text align="center"/>');
-                out.push(`<symbol type="qrcode_model_2" level="level_m" width="${breite}" height="0" size="0">${eposXmlEscape(z.qr ?? '')}</symbol>`);
+                out.push(`<symbol type="qrcode_model_2" level="level_m" width="${breite}" height="0" size="0">${eposXmlEscape(block.nutzlast)}</symbol>`);
                 out.push('<text align="left"/>');
                 break;
             }
-            case 'banner':
-                out.push(`<text width="1" height="2" reverse="${z.ton === 'warnung' ? 'true' : 'false'}" em="true">${eposXmlEscape(z.text)}&#10;</text>`);
-                out.push('<text width="1" height="1" reverse="false" em="false"/>');
-                break;
-            default:
-                if (z.bold)
-                    out.push(`<text em="true">${eposXmlEscape(z.text)}&#10;</text>`);
-                else
-                    out.push(`<text>${eposXmlEscape(z.text)}&#10;</text>`);
-                if (z.bold)
-                    out.push('<text em="false"/>');
-                break;
         }
     }
     if (options.cut !== false) {
@@ -220,6 +235,10 @@ function eposDirectPrint(layout, o, fetchFn = fetch) {
         xmlOptionen.qrBreite = o.qrBreite;
     if (o.qrGroesse !== undefined)
         xmlOptionen.qrGroesse = o.qrGroesse;
+    if (o.logo)
+        xmlOptionen.logo = o.logo;
+    if (o.marke !== undefined)
+        xmlOptionen.marke = o.marke;
     return eposDirectSend(eposPrintXml({ ...layout, paperSize: papier }, xmlOptionen), o, fetchFn);
 }
 /** Verbindungstest: leeres Dokument, druckt nichts, liefert den Druckerstatus. */