@kreiseck/kasseneck-api 0.6.7

package/dist/esm/printing/printable.js

@@ -0,0 +1,87 @@
+/**
+ * Macht Text fuer den Bondrucker druckbar — Zwilling von `_printable` und
+ * `_isEmojiOrZeroWidth` in `kasseneck_api/lib/models/print_paper.dart`
+ * (Zeilen 53-88).
+ *
+ * Warum getrennt vom Erzeuger: Die Ersetzung **aendert die Laenge** ("€" wird
+ * zu "EUR", ein Emoji verschwindet). Wer Spalten rechnet, muss den fertigen
+ * Text sehen, nicht den rohen — deshalb entscheidet der Aufrufer, wann er
+ * ersetzt, und der Erzeuger bekommt bereits druckbaren Text. Der Erzeuger
+ * selbst wirft weiterhin bei Zeichen ausserhalb Latin-1; das ist die Schicht,
+ * auf der ein Fehler noch etwas bedeutet.
+ *
+ * Regel: bekannte Sonderzeichen auf ein ASCII-Aequivalent, Latin-1 (inklusive
+ * aller deutschen Umlaute) unveraendert, Emoji und Nullbreiten-Zeichen
+ * ersatzlos weg, alles Uebrige auf `?`. Ein Artikelname aus einer
+ * ERP-Uebernahme mit Gedankenstrich soll den Beleg nicht verhindern.
+ */
+/** Ersetzungen aus print_paper.dart, Schluessel sind Unicode-Codepunkte. */
+const ERSETZUNGEN = new Map([
+    [0x2013, '-'], // – Halbgeviertstrich
+    [0x2014, '-'], // — Geviertstrich
+    [0x2011, '-'], // ‑ geschuetzter Bindestrich
+    [0x2212, '-'], // − Minus
+    [0x201c, '"'], // " oeffnendes Anfuehrungszeichen
+    [0x201d, '"'], // " schliessendes Anfuehrungszeichen
+    [0x201e, '"'], // „ tiefes Anfuehrungszeichen
+    [0x201f, '"'], // ‟
+    [0x2018, "'"], // ' einfaches Anfuehrungszeichen
+    [0x2019, "'"], // ' typografisches Apostroph
+    [0x201a, "'"], // ‚ tiefes einfaches Anfuehrungszeichen
+    [0x2032, "'"], // ′ Minutenzeichen
+    [0x2026, '...'], // … Auslassungspunkte
+    [0x2022, '*'], // • Aufzaehlungspunkt
+    [0x2713, 'x'], // ✓ Haken
+    [0x2714, 'x'], // ✔ fetter Haken
+    [0x20ac, 'EUR'], // € Euro
+    [0x2122, 'TM'], // ™ Markenzeichen
+    [0x20ba, 'TL'], // ₺ tuerkische Lira
+]);
+/**
+ * Emoji-, Modifier- und Nullbreiten-/Steuerzeichen, die auf dem Beleg nichts
+ * verloren haben. Sie werden entfernt statt zu `?` gemacht: ein einzelnes
+ * Emoji besteht oft aus mehreren Codepunkten und stuende sonst als Reihe von
+ * Fragezeichen auf dem Bon.
+ */
+function istEmojiOderNullbreite(codepunkt) {
+    return (codepunkt === 0x200d || // Zero-Width Joiner
+        (codepunkt >= 0x200b && codepunkt <= 0x200f) ||
+        codepunkt === 0x2060 ||
+        codepunkt === 0xfeff ||
+        (codepunkt >= 0xfe00 && codepunkt <= 0xfe0f) || // Variantenselektoren
+        (codepunkt >= 0x1f3fb && codepunkt <= 0x1f3ff) || // Hautton-Modifier
+        (codepunkt >= 0x1f000 && codepunkt <= 0x1faff) || // Emoji-Bloecke
+        (codepunkt >= 0x2600 && codepunkt <= 0x27bf) || // Symbole und Dingbats
+        (codepunkt >= 0x2b00 && codepunkt <= 0x2bff) || // Symbole und Pfeile
+        (codepunkt >= 0x2300 && codepunkt <= 0x23ff) // technische Symbole
+    );
+}
+/**
+ * Ersetzt alles, was der Bondrucker nicht darstellen kann, durch eine
+ * druckbare Entsprechung. Reine Funktion, ohne Zustand und ohne Drucker.
+ *
+ * Vor `escPosText`/`escPosRow` anwenden, wenn der Text aus fremder Hand kommt
+ * (Artikelstamm, ERP-Uebernahme, Kundenname). `•` wird hier zu `*`, und der
+ * Erzeuger sagt dasselbe — auch wer diese Funktion weglaesst, bekommt also
+ * dasselbe Zeichen (siehe ZEICHEN_ERSATZ in escpos.ts).
+ */
+export function escPosPrintableText(text) {
+    let ergebnis = '';
+    for (const zeichen of text) {
+        const codepunkt = zeichen.codePointAt(0);
+        const ersatz = ERSETZUNGEN.get(codepunkt);
+        if (ersatz !== undefined) {
+            ergebnis += ersatz;
+        }
+        else if (codepunkt <= 0xff) {
+            ergebnis += zeichen; // Latin-1 inklusive Umlaute bleibt unveraendert
+        }
+        else if (istEmojiOderNullbreite(codepunkt)) {
+            // ersatzlos entfernen
+        }
+        else {
+            ergebnis += '?';
+        }
+    }
+    return ergebnis;
+}

package/dist/esm/printing/webusb.d.ts

@@ -0,0 +1,89 @@
+/**
+ * Bondrucker am USB-Kabel ueber WebUSB (Chrome/Edge auf Windows, macOS,
+ * Android, ChromeOS -- kein Safari, kein iPad). Der Browser bekommt das Geraet
+ * nur, wenn kein Treiber es haelt (Windows: ggf. WinUSB statt Epson-Treiber).
+ * Die Bytes sind dieselben wie am Bluetooth-Drucker: ESC/POS aus
+ * `escPosLayoutBytes`, exakt die Rasterzeilen.
+ *
+ * Alles hier ist strukturell getippt (kein `USBDevice`-DOM-Typ noetig), damit
+ * es ohne Browser testbar bleibt und in jeder App gleich laeuft.
+ */
+export interface UsbEndpointLike {
+    direction: string;
+    type: string;
+    endpointNumber: number;
+}
+export interface UsbAlternateLike {
+    alternateSetting: number;
+    interfaceClass: number;
+    endpoints: UsbEndpointLike[];
+}
+export interface UsbInterfaceLike {
+    interfaceNumber: number;
+    alternates: UsbAlternateLike[];
+}
+export interface UsbConfigurationLike {
+    configurationValue: number;
+    interfaces: UsbInterfaceLike[];
+}
+export interface UsbTransferOutResultLike {
+    status: string;
+    bytesWritten: number;
+}
+export interface UsbWriterLike {
+    transferOut: (endpointNumber: number, data: Uint8Array) => Promise<UsbTransferOutResultLike>;
+}
+export interface UsbIdentityLike {
+    vendorId: number;
+    productId: number;
+    serialNumber?: string | null;
+}
+/** Das, was ein WebUSB-`USBDevice` bietet -- soweit hier gebraucht. */
+export interface UsbDeviceLike extends UsbWriterLike, UsbIdentityLike {
+    productName?: string | null;
+    manufacturerName?: string | null;
+    opened: boolean;
+    configuration: UsbConfigurationLike | null;
+    open: () => Promise<void>;
+    close: () => Promise<void>;
+    selectConfiguration: (value: number) => Promise<void>;
+    claimInterface: (interfaceNumber: number) => Promise<void>;
+    releaseInterface: (interfaceNumber: number) => Promise<void>;
+    selectAlternateInterface: (interfaceNumber: number, alternateSetting: number) => Promise<void>;
+}
+export interface UsbPrinterEndpoint {
+    interfaceNumber: number;
+    alternateSetting: number;
+    endpointNumber: number;
+}
+export interface UsbPrinterConnection {
+    device: UsbDeviceLike;
+    /** "Hersteller Produkt", z. B. "EPSON TM-T20III". */
+    name: string;
+    interfaceNumber: number;
+    endpointNumber: number;
+    /** Kennung fuers Wiederfinden ueber `navigator.usb.getDevices()`. */
+    key: string;
+}
+/** Epson Seiko USB-Vendor-ID -- als Vorfilter im Geraetedialog. */
+export declare const USB_VENDOR_EPSON = 1208;
+/** USB-Geraeteklasse "Drucker". */
+export declare const USB_CLASS_PRINTER = 7;
+/** Kennung `vvvv:pppp:serial` -- stabil ueber Neustarts, wenn der Drucker eine Seriennummer meldet. */
+export declare function usbDeviceKey(d: UsbIdentityLike): string;
+/** Druckerschnittstelle (Klasse 7) bevorzugt, sonst herstellerspezifisch (0xFF), sonst irgendein Bulk-OUT. */
+export declare function usbFindPrinterEndpoint(d: {
+    configuration: UsbConfigurationLike | null;
+}): UsbPrinterEndpoint | null;
+/** Bytes blockweise an den OUT-Endpunkt; liefert die geschriebene Gesamtzahl, wirft bei Fehlstatus. */
+export declare function usbWriteAll(dev: UsbWriterLike, endpointNumber: number, bytes: Uint8Array, blockSize?: number): Promise<number>;
+/**
+ * Geraet oeffnen, Konfiguration waehlen, Druckerschnittstelle belegen. Wirft
+ * verstaendlich, wenn ein Treiber das Geraet haelt oder kein Drucker-Endpunkt
+ * da ist -- und schliesst das Geraet dann wieder.
+ */
+export declare function usbConnectPrinter(device: UsbDeviceLike): Promise<UsbPrinterConnection>;
+/** Bytes an eine bestehende Verbindung. */
+export declare function usbPrint(c: UsbPrinterConnection, bytes: Uint8Array): Promise<number>;
+/** Schnittstelle freigeben und schliessen; Fehler dabei sind egal (Geraet ist ohnehin weg). */
+export declare function usbDisconnect(c: UsbPrinterConnection): Promise<void>;

package/dist/esm/printing/webusb.js

@@ -0,0 +1,101 @@
+/**
+ * Bondrucker am USB-Kabel ueber WebUSB (Chrome/Edge auf Windows, macOS,
+ * Android, ChromeOS -- kein Safari, kein iPad). Der Browser bekommt das Geraet
+ * nur, wenn kein Treiber es haelt (Windows: ggf. WinUSB statt Epson-Treiber).
+ * Die Bytes sind dieselben wie am Bluetooth-Drucker: ESC/POS aus
+ * `escPosLayoutBytes`, exakt die Rasterzeilen.
+ *
+ * Alles hier ist strukturell getippt (kein `USBDevice`-DOM-Typ noetig), damit
+ * es ohne Browser testbar bleibt und in jeder App gleich laeuft.
+ */
+/** Epson Seiko USB-Vendor-ID -- als Vorfilter im Geraetedialog. */
+export const USB_VENDOR_EPSON = 0x04b8;
+/** USB-Geraeteklasse "Drucker". */
+export const USB_CLASS_PRINTER = 7;
+const HEX4 = (n) => n.toString(16).padStart(4, '0');
+/** Kennung `vvvv:pppp:serial` -- stabil ueber Neustarts, wenn der Drucker eine Seriennummer meldet. */
+export function usbDeviceKey(d) {
+    return `${HEX4(d.vendorId)}:${HEX4(d.productId)}:${d.serialNumber ?? ''}`;
+}
+/** Druckerschnittstelle (Klasse 7) bevorzugt, sonst herstellerspezifisch (0xFF), sonst irgendein Bulk-OUT. */
+export function usbFindPrinterEndpoint(d) {
+    const konf = d.configuration;
+    if (!konf)
+        return null;
+    const kandidaten = [];
+    for (const i of konf.interfaces) {
+        for (const alt of i.alternates) {
+            const ep = alt.endpoints.find((x) => x.direction === 'out' && x.type === 'bulk');
+            if (!ep)
+                continue;
+            const rang = alt.interfaceClass === USB_CLASS_PRINTER ? 0 : alt.interfaceClass === 0xff ? 1 : 2;
+            kandidaten.push({ rang, e: { interfaceNumber: i.interfaceNumber, alternateSetting: alt.alternateSetting, endpointNumber: ep.endpointNumber } });
+        }
+    }
+    kandidaten.sort((a, b) => a.rang - b.rang);
+    return kandidaten[0]?.e ?? null;
+}
+/** Bytes blockweise an den OUT-Endpunkt; liefert die geschriebene Gesamtzahl, wirft bei Fehlstatus. */
+export async function usbWriteAll(dev, endpointNumber, bytes, blockSize = 16384) {
+    const groesse = Math.max(1, Math.floor(blockSize));
+    let n = 0;
+    for (let von = 0; von < bytes.length; von += groesse) {
+        // eigener ArrayBuffer je Block (BufferSource verlangt kein SharedArrayBuffer)
+        const block = new Uint8Array(Math.min(groesse, bytes.length - von));
+        block.set(bytes.subarray(von, von + block.length));
+        const r = await dev.transferOut(endpointNumber, block);
+        if (r.status !== 'ok')
+            throw new Error(`USB-Übertragung: ${r.status} nach ${n} Byte`);
+        n += r.bytesWritten;
+    }
+    return n;
+}
+/**
+ * Geraet oeffnen, Konfiguration waehlen, Druckerschnittstelle belegen. Wirft
+ * verstaendlich, wenn ein Treiber das Geraet haelt oder kein Drucker-Endpunkt
+ * da ist -- und schliesst das Geraet dann wieder.
+ */
+export async function usbConnectPrinter(device) {
+    if (!device.opened)
+        await device.open();
+    try {
+        if (!device.configuration)
+            await device.selectConfiguration(1);
+        const ep = usbFindPrinterEndpoint(device);
+        if (!ep)
+            throw new Error('Kein Drucker-Endpunkt am USB-Gerät gefunden — ist das ein Bondrucker?');
+        try {
+            await device.claimInterface(ep.interfaceNumber);
+        }
+        catch (e) {
+            const grund = e instanceof Error && e.message ? ` (${e.message})` : '';
+            throw new Error(`USB-Schnittstelle belegt${grund} — ein Treiber hält den Drucker. Windows: Epson-Treiber entfernen oder mit Zadig auf WinUSB umstellen.`);
+        }
+        if (ep.alternateSetting !== 0)
+            await device.selectAlternateInterface(ep.interfaceNumber, ep.alternateSetting);
+        const name = [device.manufacturerName, device.productName].filter((t) => !!t).join(' ') || 'USB-Drucker';
+        return { device, name, interfaceNumber: ep.interfaceNumber, endpointNumber: ep.endpointNumber, key: usbDeviceKey(device) };
+    }
+    catch (e) {
+        try {
+            await device.close();
+        }
+        catch { /* schon zu */ }
+        throw e;
+    }
+}
+/** Bytes an eine bestehende Verbindung. */
+export function usbPrint(c, bytes) {
+    return usbWriteAll(c.device, c.endpointNumber, bytes);
+}
+/** Schnittstelle freigeben und schliessen; Fehler dabei sind egal (Geraet ist ohnehin weg). */
+export async function usbDisconnect(c) {
+    try {
+        await c.device.releaseInterface(c.interfaceNumber);
+    }
+    catch { /* egal */ }
+    try {
+        await c.device.close();
+    }
+    catch { /* egal */ }
+}

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

@@ -0,0 +1,46 @@
+import { type ReactNode } from 'react';
+import type { ReceiptLayout } from '../receipt/layout.js';
+/**
+ * React-Adapter: zeichnet ein Beleg-Layout (siehe ../receipt/layout.ts).
+ *
+ * Eigener Einstiegspunkt `@kreiseck/kasseneck-api/react`. **React ist eine
+ * Peer-Abhaengigkeit**: wer nur Belege erzeugt, Bytes druckt oder ein Layout
+ * baut, soll React weder installieren noch laden muessen. Der Kern des Pakets
+ * ruehrt diese Datei deshalb nirgends an — ein Test haelt das fest.
+ *
+ * Der Adapter bringt bewusst kein Aussehen mit: Struktur, Ausrichtung und
+ * Betonung stehen im Markup, alles Weitere (Schriftart, Breite, Farben) macht
+ * das Stylesheet des Verbrauchers ueber die `keck-receipt-*`-Klassen. Ein
+ * Bon ist einspaltig und schmal; er sieht in jeder Anwendung anders aus.
+ *
+ * Der QR-Code wird **nicht** gezeichnet — dafuer braucht es einen QR-Erzeuger,
+ * und welchen, entscheidet die Anwendung. Vorgabe ist ein leeres Element, das
+ * die Nutzlast als `data-qr` traegt; ueber [ReceiptLayoutViewProps.renderQr]
+ * setzt der Aufrufer seinen eigenen Zeichner ein.
+ */
+export interface ReceiptLayoutViewProps {
+    layout: ReceiptLayout;
+    /** Zusaetzliche Klasse am aeusseren Element. */
+    className?: string;
+    /** Zeichnet den RKSV-QR-Code; ohne Angabe erscheint ein Platzhalter mit `data-qr`. */
+    renderQr?: (data: string) => ReactNode;
+    /**
+     * QR zunaechst verdeckt (weichgezeichnet) zeigen; ein Tipp macht ihn lesbar.
+     * Fuer Bildschirme, auf denen der Beleg nur zur Kontrolle steht -- der
+     * Signatur-QR gehoert dem Kunden und wird erst auf Verlangen freigegeben.
+     */
+    qrVerdeckt?: boolean;
+    /** Text auf dem verdeckten QR (Vorgabe „Antippen zum Anzeigen“). */
+    qrVerdecktText?: string;
+}
+export declare function ReceiptLayoutView({ layout, className, renderQr, qrVerdeckt, qrVerdecktText }: ReceiptLayoutViewProps): ReactNode;
+/**
+ * Verdeckter QR: weichgezeichnet und nicht scannbar, bis der Betrachter ihn
+ * antippt. Die Nutzlast bleibt trotzdem als `data-qr` am Element -- fuer Tests
+ * und Werkzeuge, nicht fuers Auge.
+ */
+export declare function QrVerdeckt({ data, text, children }: {
+    data: string;
+    text?: string;
+    children: ReactNode;
+}): ReactNode;

package/dist/esm/react/index.js

@@ -0,0 +1,47 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState } from 'react';
+const AUSRICHTUNG = {
+    left: 'left',
+    center: 'center',
+    right: 'right',
+};
+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))) }));
+}
+/**
+ * Verdeckter QR: weichgezeichnet und nicht scannbar, bis der Betrachter ihn
+ * antippt. Die Nutzlast bleibt trotzdem als `data-qr` am Element -- fuer Tests
+ * und Werkzeuge, nicht fuers Auge.
+ */
+export function QrVerdeckt({ data, text = 'Antippen zum Anzeigen', children }) {
+    const [offen, setOffen] = useState(false);
+    return (_jsxs("button", { type: "button", className: offen ? 'keck-receipt-qr-toggle keck-receipt-qr-toggle--offen' : 'keck-receipt-qr-toggle', "aria-pressed": offen, "aria-label": offen ? 'QR-Code verdecken' : 'QR-Code anzeigen', "data-qr": data, onClick: () => setOffen((o) => !o), style: { position: 'relative', display: 'inline-block', border: 'none', background: 'transparent', padding: 0, cursor: 'pointer' }, children: [_jsx("span", { style: { display: 'inline-block', filter: offen ? undefined : 'blur(6px)', transition: 'filter .15s ease' }, children: children }), !offen && (_jsx("span", { className: "keck-receipt-qr-toggle-text", style: { position: 'absolute', inset: 0, display: 'grid', placeItems: 'center', fontSize: '0.75em', fontWeight: 700 }, children: text }))] }));
+}
+function Zeile({ zeile, renderQr, qrVerdeckt, qrVerdecktText }) {
+    switch (zeile.kind) {
+        case 'text':
+            return (_jsx("div", { className: "keck-receipt-text", style: { textAlign: AUSRICHTUNG[zeile.align], fontWeight: zeile.bold ? 'bold' : 'normal' }, children: zeile.text.length > 0 ? zeile.text : ' ' }));
+        case 'columns':
+            return (_jsx("div", { className: "keck-receipt-row", style: { display: 'flex', width: '100%' }, children: zeile.columns.map((spalte, index) => (_jsx("div", { className: "keck-receipt-cell", style: {
+                        // Die Breite ist ein Zwoelftel-Anteil (wie beim Bondrucker);
+                        // so bleibt die Aufteilung auf allen Ausgabewegen dieselbe.
+                        flex: `0 0 ${((spalte.width / 12) * 100).toFixed(4)}%`,
+                        textAlign: AUSRICHTUNG[spalte.align],
+                        overflowWrap: 'break-word',
+                    }, children: spalte.text }, index))) }));
+        case 'rule':
+            // Echte Linie statt einer Reihe Bindestriche: auf dem Bildschirm haengt
+            // deren Anzahl sonst an der Schriftbreite.
+            return _jsx("hr", { className: "keck-receipt-rule", "data-char": zeile.char });
+        case 'space':
+            return _jsx("div", { className: "keck-receipt-space", style: { height: `${zeile.lines}em` } });
+        case 'banner':
+            return (_jsx("div", { className: `keck-receipt-banner keck-receipt-banner--${zeile.ton}`, role: zeile.ton === 'warnung' ? 'alert' : undefined, style: { textAlign: 'center', fontWeight: 'bold', letterSpacing: '0.06em', padding: '0.2em 0.4em', border: '2px solid currentColor', margin: '0.3em 0' }, children: zeile.text }));
+        case 'qr':
+            {
+                const bild = renderQr !== undefined ? renderQr(zeile.data) : _jsx("div", { "data-qr": zeile.data, "aria-label": "RKSV-QR-Code" });
+                return (_jsx("div", { className: "keck-receipt-qr", style: { textAlign: 'center' }, children: qrVerdeckt ? _jsx(QrVerdeckt, { data: zeile.data, text: qrVerdecktText, children: bild }) : bild }));
+            }
+    }
+}

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

@@ -0,0 +1,12 @@
+import type { ReceiptItem } from '../models/receipt-item.js';
+/**
+ * Rabatt als negative Position(en) — eine je Steuersatz, anteilig zum
+ * Bruttoumsatz dieses Satzes. So stimmt die MwSt-Tabelle des Belegs immer, das
+ * DEP zeigt den Rabatt als Position, und Backend/Signatur bleiben unberuehrt
+ * (createReceipt erlaubt negative Positionen).
+ *
+ * Rundung nach dem groessten Rest (Hare-Niemeyer): die Cent, die beim
+ * Abrunden uebrig bleiben, gehen der Reihe nach an die Gruppen mit dem
+ * groessten Bruchteil; keine Zeile ist je groesser als der Umsatz ihres Satzes.
+ */
+export declare function verteileRabatt(positionen: ReceiptItem[], rabattCents: number, name?: string): ReceiptItem[];

package/dist/esm/receipt/discount.js

@@ -0,0 +1,51 @@
+import { receiptItemTotalCents } from '../models/receipt-item.js';
+/**
+ * Rabatt als negative Position(en) — eine je Steuersatz, anteilig zum
+ * Bruttoumsatz dieses Satzes. So stimmt die MwSt-Tabelle des Belegs immer, das
+ * DEP zeigt den Rabatt als Position, und Backend/Signatur bleiben unberuehrt
+ * (createReceipt erlaubt negative Positionen).
+ *
+ * Rundung nach dem groessten Rest (Hare-Niemeyer): die Cent, die beim
+ * Abrunden uebrig bleiben, gehen der Reihe nach an die Gruppen mit dem
+ * groessten Bruchteil; keine Zeile ist je groesser als der Umsatz ihres Satzes.
+ */
+export function verteileRabatt(positionen, rabattCents, name = 'Rabatt') {
+    if (!Number.isInteger(rabattCents) || rabattCents < 0) {
+        throw new Error('Rabatt muss eine ganze Zahl in Cent >= 0 sein');
+    }
+    if (rabattCents === 0)
+        return [];
+    // Umsatz je Steuersatz (nur positive Positionen -- Rabatte/Stornos zaehlen nicht mit)
+    const gruppen = new Map();
+    for (const p of positionen) {
+        const betrag = receiptItemTotalCents(p);
+        if (betrag <= 0)
+            continue;
+        const key = typeof p.vat === 'object' ? p.vat.value : String(p.vat);
+        const g = gruppen.get(key) ?? { vat: p.vat, umsatz: 0 };
+        g.umsatz += betrag;
+        gruppen.set(key, g);
+    }
+    const gesamt = [...gruppen.values()].reduce((s, g) => s + g.umsatz, 0);
+    if (rabattCents > gesamt)
+        throw new Error('Rabatt uebersteigt den Umsatz');
+    const liste = [...gruppen.values()];
+    const exakt = liste.map((g) => (rabattCents * g.umsatz) / gesamt);
+    const anteile = exakt.map((x) => Math.floor(x));
+    let rest = rabattCents - anteile.reduce((s, a) => s + a, 0);
+    // Reihenfolge fuer die Restcent: groesster Bruchteil zuerst, bei Gleichstand groesserer Umsatz
+    const reihenfolge = liste.map((_, i) => i).sort((a, b) => (exakt[b] - anteile[b]) - (exakt[a] - anteile[a]) || liste[b].umsatz - liste[a].umsatz);
+    for (let runde = 0; rest > 0 && runde < liste.length + 1; runde++) {
+        for (const i of reihenfolge) {
+            if (rest === 0)
+                break;
+            if (anteile[i] < liste[i].umsatz) {
+                anteile[i] += 1;
+                rest -= 1;
+            }
+        }
+    }
+    return liste
+        .map((g, i) => ({ name, quantity: 1, vat: g.vat, priceCents: -anteile[i] }))
+        .filter((z) => z.priceCents < 0);
+}

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

@@ -0,0 +1,53 @@
+import type { ReceiptLayout } from './layout.js';
+import type { PosPaperSize } from '../printing/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
+ * eigenes Setzen -- was Bildschirm, ESC/POS und PDF zeigen, druckt der Epson
+ * Zeile fuer Zeile genauso.
+ *
+ * Nur der Inhalt <epos-print …>…</epos-print>; die Huelle (PrintRequestInfo
+ * fuer Server Direct Print bzw. SOAP fuer ePOS-Print) baut der Aufrufer.
+ */
+export interface EposPrintXmlOptions {
+    /** Zeichen je Zeile; Vorgabe nach `layout.paperSize` (32/48). */
+    zeichen?: number;
+    /** QR-Modulgroesse (Epson `width` 3..16), Vorgabe 6. */
+    qrBreite?: number;
+    /** Papierschnitt am Ende, Vorgabe true. */
+    cut?: boolean;
+}
+export declare function eposXmlEscape(text: string): string;
+export declare function eposPrintXml(layout: ReceiptLayout, options?: EposPrintXmlOptions): string;
+/**
+ * Epson-Drucker mit ePOS-Print direkt aus dem Browser ansprechen (ohne
+ * Server-Umweg): POST an `https://<ip>/cgi-bin/epos/service.cgi`. Der Drucker
+ * antwortet mit CORS- und Private-Network-Headern (am TM-T20 nachgemessen);
+ * sein selbstsigniertes Zertifikat muss der Browser einmal akzeptiert haben.
+ * Modelle ohne Server Direct Print (TM-T20 & Co.) drucken so trotzdem aus
+ * Kasse, Panel und Labor.
+ */
+export interface EposDirectOptions {
+    /** IPv4/Hostname des Druckers im lokalen Netz. */
+    ip: string;
+    /** ePOS Device ID (Druckermenue), Vorgabe `local_printer`. */
+    devid?: string;
+    /** Papier des Druckers -- bestimmt das Raster; Vorgabe: das des Layouts. */
+    papier?: PosPaperSize;
+    timeoutMs?: number;
+}
+export interface EposResponse {
+    success: boolean;
+    /** Epson-Fehlercode (`EPTR_COVER_OPEN`, `EPTR_REC_EMPTY`, ...), leer bei Erfolg; `keine_antwort` bei unlesbarer Antwort. */
+    code: string;
+    status: string;
+}
+export declare function eposServiceUrl(ip: string, devid?: string, timeoutMs?: number): string;
+export declare function eposSoapEnvelope(innerXml: string): string;
+export declare function eposParseResponse(text: string): EposResponse;
+/** Beleg direkt drucken; wirft bei Netz-/Zertifikatsproblemen, sonst die Drucker-Antwort. */
+export declare function eposDirectPrint(layout: ReceiptLayout, o: EposDirectOptions, fetchFn?: typeof fetch): Promise<EposResponse>;
+/** Verbindungstest: leeres Dokument, druckt nichts, liefert den Druckerstatus. */
+export declare function eposDirectStatus(o: EposDirectOptions, fetchFn?: typeof fetch): Promise<EposResponse>;

package/dist/esm/receipt/epos.js

@@ -0,0 +1,86 @@
+import { renderReceiptGrid, ZEICHEN_JE_PAPIER } from './grid.js';
+export function eposXmlEscape(text) {
+    return text.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;').replace(/'/g, '&apos;');
+}
+const NS = 'http://www.epson-pos.com/schemas/2011/03/epos-print';
+export function eposPrintXml(layout, options = {}) {
+    const grid = renderReceiptGrid(layout, { zeichen: options.zeichen ?? ZEICHEN_JE_PAPIER[layout.paperSize] });
+    const qrBreite = Math.min(16, Math.max(3, Math.floor(options.qrBreite ?? 6)));
+    const out = [];
+    out.push(`<epos-print xmlns="${NS}">`);
+    out.push('<text lang="de"/>');
+    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"/>');
+                break;
+            case 'qr':
+                out.push('<text align="center"/>');
+                out.push(`<symbol type="qrcode_model_2" level="level_m" width="${qrBreite}" height="0" size="0">${eposXmlEscape(z.qr ?? '')}</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) {
+        out.push('<feed line="2"/>');
+        out.push('<cut type="feed"/>');
+    }
+    out.push('</epos-print>');
+    return out.join('\n');
+}
+const EPOS_DEVID_VORGABE = 'local_printer';
+export function eposServiceUrl(ip, devid = EPOS_DEVID_VORGABE, timeoutMs = 10000) {
+    const adresse = ip.trim();
+    if (!adresse || !/^[A-Za-z0-9.\-:]+$/.test(adresse))
+        throw new Error('Drucker-IP fehlt oder ist ungueltig.');
+    const geraet = devid.trim() || EPOS_DEVID_VORGABE;
+    return `https://${adresse}/cgi-bin/epos/service.cgi?devid=${encodeURIComponent(geraet)}&timeout=${Math.max(1000, Math.floor(timeoutMs))}`;
+}
+export function eposSoapEnvelope(innerXml) {
+    return '<?xml version="1.0" encoding="utf-8"?><s:Envelope xmlns:s="http://schemas.xmlsoap.org/soap/envelope/"><s:Body>' + innerXml + '</s:Body></s:Envelope>';
+}
+export function eposParseResponse(text) {
+    const m = /<response\b([^>]*)>/.exec(text);
+    if (!m)
+        return { success: false, code: 'keine_antwort', status: '' };
+    const attr = (n) => new RegExp(`\\b${n}="([^"]*)"`).exec(m[1] ?? '')?.[1] ?? '';
+    return { success: attr('success') === 'true', code: attr('code'), status: attr('status') };
+}
+async function eposDirectSend(innerXml, o, fetchFn) {
+    const url = eposServiceUrl(o.ip, o.devid ?? EPOS_DEVID_VORGABE, o.timeoutMs ?? 10000);
+    let antwort;
+    try {
+        antwort = await fetchFn(url, { method: 'POST', headers: { 'Content-Type': 'text/xml; charset=utf-8', SOAPAction: '""' }, body: eposSoapEnvelope(innerXml) });
+    }
+    catch {
+        throw new Error(`Drucker nicht erreichbar. Einmal https://${o.ip.trim()} im Browser öffnen und das Zertifikat akzeptieren, ` +
+            'Zugriff aufs lokale Netz erlauben, ePOS-Print am Drucker auf Enable.');
+    }
+    if (!antwort.ok)
+        throw new Error(`Drucker antwortet mit HTTP ${antwort.status}.`);
+    return eposParseResponse(await antwort.text());
+}
+/** Beleg direkt drucken; wirft bei Netz-/Zertifikatsproblemen, sonst die Drucker-Antwort. */
+export function eposDirectPrint(layout, o, fetchFn = fetch) {
+    const papier = o.papier ?? layout.paperSize;
+    return eposDirectSend(eposPrintXml({ ...layout, paperSize: papier }, { zeichen: ZEICHEN_JE_PAPIER[papier] }), o, fetchFn);
+}
+/** Verbindungstest: leeres Dokument, druckt nichts, liefert den Druckerstatus. */
+export function eposDirectStatus(o, fetchFn = fetch) {
+    return eposDirectSend(`<epos-print xmlns="${NS}"/>`, o, fetchFn);
+}

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

@@ -0,0 +1,47 @@
+import type { ReceiptLayout } from './layout.js';
+import type { PosPaperSize } from '../printing/escpos.js';
+/**
+ * Zeichenraster: der Beleg als Zeilen mit **exakt N Zeichen** -- die einzige
+ * Wahrheit fuer Bildschirm, Bondruck und PDF. Kein Ausgabeweg rechnet
+ * Spalten selbst; wer das Raster setzt, setzt den Beleg.
+ *
+ * Regeln (fest, damit ueberall dasselbe herauskommt):
+ * - Papier 58 mm = 32 Zeichen, 80 mm = 48 (Font A); andere Breiten per Option.
+ * - Spalten in Zwoelfteln -> ganze Zeichen: `floor(N*w/12)`, der Rest an die
+ *   letzte Spalte, jede mindestens 1. Zwischen zwei Spalten steht immer
+ *   mindestens ein Leerzeichen (letztes Zeichen jeder nicht-letzten Spalte).
+ *   Die letzte Spalte endet buendig am rechten Rand.
+ * - Text/Aufdruck/Spalteninhalt bricht **wortweise** um (`wortzeilenText`,
+ *   dieselbe Regel wie der ESC/POS-Kern); ueberlange Woerter nach einem
+ *   Bindestrich, sonst hart; geschuetztes Leerzeichen bricht nie.
+ * - Fliessregel: laeuft in einer Spaltenzeile nur eine Spalte ueber die erste
+ *   Zeile hinaus, bekommt ihr Rest die volle Breite (lange Artikelnamen auf
+ *   58 mm); laufen mehrere weiter, bleibt das Raster.
+ * - Trennlinie ueber die volle Breite, Leerraum als Leerzeilen, QR als eigene
+ *   Zeile mit Nutzlast (der Zeichner setzt das Bild).
+ */
+export declare const ZEICHEN_JE_PAPIER: Readonly<Record<PosPaperSize, number>>;
+export type GridLineKind = 'text' | 'columns' | 'rule' | 'space' | 'qr' | 'banner';
+export interface GridLine {
+    /** Genau `zeichen` Zeichen (bei `qr`: zentrierter Platzhalter). */
+    text: string;
+    kind: GridLineKind;
+    bold: boolean;
+    /** Bei `banner`: `warnung` = invers/auffaellig, `belegart` = Rahmen. */
+    ton?: 'belegart' | 'warnung';
+    /** Bei `qr`: die Nutzlast. */
+    qr?: string;
+}
+export interface ReceiptGrid {
+    lines: GridLine[];
+    zeichen: number;
+}
+export interface RenderReceiptGridOptions {
+    /** Zeichen je Zeile; Vorgabe nach `layout.paperSize` (32/48). */
+    zeichen?: number;
+}
+/** Zwoelftel -> Zeichen je Spalte (ganze Zeichen, Rest an die letzte, mindestens 1). */
+export declare function gridSpaltenBreiten(zwoelftel: readonly number[], zeichen: number): number[];
+export declare function renderReceiptGrid(layout: ReceiptLayout, options?: RenderReceiptGridOptions): ReceiptGrid;
+/** Klartext (eine Zeile je Rasterzeile) -- fuer Golden-Dateien und Logs. QR als Platzhalter. */
+export declare function gridAlsText(grid: ReceiptGrid): string;