@kreiseck/kasseneck-api 0.31.0 → 1.0.0-rc.2

package/dist/esm/receipt/due.js

@@ -0,0 +1,257 @@
+import { ReceiptType, VoucherAction, VoucherType } from '../enums/index.js';
+const UMSATZ = new Set(['standard', 'cancellation', 'training']);
+const TRINKGELD_ERLAUBT = new Set(['standard', 'training']);
+const ZAHLARTEN = new Set(['cash', 'creditCard', 'online', 'uberApp', 'uberCard', 'uberCash', 'boltApp', 'boltCard', 'boltCash']);
+/** Zahlbetrag in Cent, siehe Modulkommentar. */
+export function receiptDueCents(items, vouchers, receiptType, options = {}) {
+    return receiptDueBreakdown(items, vouchers, receiptType, options).dueCents;
+}
+/** Wie [receiptDueCents], dazu Zaehler-Delta, Wertgutschein-Anteil und Toepfe. */
+export function receiptDueBreakdown(items, vouchers, receiptType, options = {}) {
+    const art = belegArt(receiptType);
+    const trinkgelder = trinkgeldAuftraege(options);
+    if (trinkgelder.length > 0 && !TRINKGELD_ERLAUBT.has(art)) {
+        throw new RangeError(`Zahlbetrag: Trinkgeld gibt es nur bei standard und training, nicht bei "${art}".`);
+    }
+    if (!UMSATZ.has(art)) {
+        return { dueCents: 0, counterDeltaCents: 0, valueVoucherFlowCents: 0, bucketsCents: null };
+    }
+    const positionen = items.map(innen);
+    const gutscheine = vouchers.map(gutscheinInnen);
+    // index.js createReceipt: erst `tip`, dann je Zahlart aus payments[].tipCents;
+    // jede Runde haengt ihre Positionen hinten an (die Basis bleibt die Ware).
+    for (const auftrag of trinkgelder)
+        positionen.push(...trinkgeldPositionen(auftrag, positionen, options.tipRecipient));
+    const t = belegToepfe(positionen, gutscheine);
+    const fluss = wertgutscheinFlussCents(gutscheine, art);
+    return {
+        dueCents: t.zaehlerDeltaCents + fluss,
+        counterDeltaCents: t.zaehlerDeltaCents,
+        valueVoucherFlowCents: fluss,
+        bucketsCents: {
+            amountRateStandard: euroToCent(t.amountRateStandard),
+            amountRateReduced1: euroToCent(t.amountRateReduced1),
+            amountRateReduced2: euroToCent(t.amountRateReduced2),
+            amountRateZero: euroToCent(t.amountRateZero),
+            amountRateSpecial: euroToCent(t.amountRateSpecial),
+            amountRatOthers: euroToCent(t.amountRatOthers),
+        },
+    };
+}
+function belegArt(wert) {
+    const text = typeof wert === 'object' && wert !== null ? wert.value : wert;
+    if (typeof text !== 'string' || !Object.prototype.hasOwnProperty.call(ReceiptType, text)) {
+        throw new RangeError(`Zahlbetrag: unbekannter Belegtyp "${String(text)}".`);
+    }
+    return text;
+}
+/** `beleg-toepfe.euroToCent`; `+ 0` macht aus einem negativen Null ein Null. */
+function euroToCent(euro) {
+    return Math.round(euro * 100) + 0;
+}
+/** Position in die innere Form: Einzelpreis `Math.round(cents) / 100` wie `interneForm`. */
+function innen(item, i) {
+    const satz = typeof item.vat === 'number' ? item.vat : item.vat?.rate;
+    if (typeof satz !== 'number' || !Number.isFinite(satz))
+        throw new RangeError(`Zahlbetrag: Position ${i + 1} ohne Steuersatz.`);
+    if (!Number.isSafeInteger(item.priceCents))
+        throw new RangeError(`Zahlbetrag: Position ${i + 1} hat keinen ganzen Cent-Preis.`);
+    if (typeof item.quantity !== 'number' || !Number.isFinite(item.quantity))
+        throw new RangeError(`Zahlbetrag: Position ${i + 1} hat keine gueltige Menge.`);
+    const tip = item.kind === 'tip' ? (item.recipient?.owner === true ? 'owner' : 'staff') : null;
+    return { amount: item.quantity, priceOne: Math.round(item.priceCents) / 100, vat: satz, tip };
+}
+function gutscheinInnen(v, i) {
+    if (!Number.isSafeInteger(v.valueCents))
+        throw new RangeError(`Zahlbetrag: Gutschein ${i + 1} hat keinen ganzen Cent-Wert.`);
+    return { action: String(v.action), type: String(v.type), value: Math.round(v.valueCents) / 100 };
+}
+/** Trinkgeld-Auftraege in der Reihenfolge des Servers: `tip`, dann je Zahlart die Summe der `tipCents`. */
+function trinkgeldAuftraege(options) {
+    const raus = [];
+    const tipCents = (options.payments ?? []).some((z) => z != null && z.tipCents !== undefined);
+    if (options.tip != null && tipCents) {
+        throw new RangeError('Zahlbetrag: tip und payments[].tipCents gehen nicht zugleich (tip_conflict).');
+    }
+    if (options.tip != null) {
+        const tip = options.tip;
+        const cents = typeof tip === 'number' ? tip : tip.cents;
+        pruefeCent(cents, 'Trinkgeld');
+        const recipients = typeof tip === 'number' ? undefined : tip.recipients;
+        if (recipients != null) {
+            if (recipients.length === 0)
+                throw new RangeError('Zahlbetrag: recipients darf nicht leer sein.');
+            for (const r of recipients) {
+                pruefeCent(r.cents, 'Trinkgeld-Anteil');
+                if (typeof r.owner !== 'boolean')
+                    throw new RangeError('Zahlbetrag: recipients[].owner muss true oder false sein.');
+            }
+            if (recipients.reduce((s, r) => s + r.cents, 0) !== cents) {
+                throw new RangeError('Zahlbetrag: die Anteile des Trinkgelds ergeben nicht den Betrag.');
+            }
+            raus.push({ empfaenger: recipients.map((r) => ({ cents: r.cents, owner: r.owner })) });
+        }
+        else {
+            raus.push({ empfaenger: [{ cents, owner: null }] });
+        }
+    }
+    // zahlungen-core.tipsJeZahlart: Summe je bekannter Zahlart, Reihenfolge des ersten Auftretens.
+    const je = new Map();
+    for (const z of options.payments ?? []) {
+        if (z == null || z.tipCents === undefined)
+            continue;
+        pruefeCent(z.tipCents, 'tipCents');
+        const methode = typeof z.method === 'object' && z.method !== null ? z.method.value : z.method;
+        if (typeof methode !== 'string' || !ZAHLARTEN.has(methode))
+            throw new RangeError(`Zahlbetrag: unbekannte Zahlart "${String(methode)}".`);
+        je.set(methode, (je.get(methode) ?? 0) + z.tipCents);
+    }
+    for (const cents of je.values())
+        raus.push({ empfaenger: [{ cents, owner: null }] });
+    return raus;
+}
+function pruefeCent(wert, was) {
+    if (typeof wert !== 'number' || !Number.isInteger(wert) || wert <= 0) {
+        throw new RangeError(`Zahlbetrag: ${was} muss eine ganze Zahl in Cent > 0 sein.`);
+    }
+}
+/** `tip-core.buildTipItems`: Personal in den Null-%-Satz, Inhaber anteilig auf die Saetze der Ware. */
+function trinkgeldPositionen(auftrag, positionen, standard) {
+    const basis = warenCentsJeSatz(positionen);
+    const summe = Object.values(basis).reduce((s, c) => s + c, 0);
+    if (summe <= 0)
+        throw new RangeError('Zahlbetrag: Trinkgeld braucht mindestens eine Position mit Betrag.');
+    const raus = [];
+    for (const e of auftrag.empfaenger) {
+        let owner = e.owner;
+        if (owner == null) {
+            if (standard !== 'owner' && standard !== 'staff') {
+                throw new RangeError("Zahlbetrag: tipRecipient fehlt ('owner' oder 'staff', wie der angemeldete Kassen-Benutzer).");
+            }
+            owner = standard === 'owner';
+        }
+        if (!owner) {
+            raus.push({ amount: 1, priceOne: e.cents / 100, vat: 0, tip: 'staff' });
+            continue;
+        }
+        const teile = splitOwnerTip(e.cents, basis);
+        if (teile.length === 0)
+            throw new RangeError('Zahlbetrag: Inhaber-Trinkgeld braucht mindestens eine Position mit Betrag.');
+        for (const teil of teile) {
+            if (teil.cents !== 0)
+                raus.push({ amount: 1, priceOne: teil.cents / 100, vat: teil.vat, tip: 'owner' });
+        }
+    }
+    return raus;
+}
+/** `tip-core.warenCentsJeSatz`: Summe je Satz in Euro, dann einmal runden. */
+function warenCentsJeSatz(positionen) {
+    const roh = {};
+    for (const p of positionen) {
+        if (p.tip != null)
+            continue;
+        roh[p.vat] = (roh[p.vat] ?? 0) + p.amount * p.priceOne;
+    }
+    const raus = {};
+    for (const [satz, wert] of Object.entries(roh))
+        raus[satz] = Math.round(wert * 100);
+    return raus;
+}
+/** `tip-core.splitOwnerTip`. */
+function splitOwnerTip(cents, jeSatz) {
+    const saetze = Object.entries(jeSatz)
+        .map(([vat, c]) => ({ vat: Number(vat), basis: c }))
+        .filter((s) => Number.isFinite(s.vat) && s.basis > 0)
+        .sort((a, b) => b.vat - a.vat);
+    const basis = saetze.reduce((s, x) => s + x.basis, 0);
+    if (basis <= 0)
+        return [];
+    let vergeben = 0;
+    const verteilt = saetze.map((s) => {
+        const exakt = (cents * s.basis) / basis;
+        const anteil = Math.floor(exakt);
+        vergeben += anteil;
+        return { vat: s.vat, cents: anteil, frac: exakt - anteil };
+    });
+    const rest = cents - vergeben;
+    if (rest > 0) {
+        let bester = verteilt[0];
+        for (const e of verteilt)
+            if (e.frac > bester.frac || (e.frac === bester.frac && e.vat > bester.vat))
+                bester = e;
+        bester.cents += rest;
+    }
+    return verteilt.map(({ vat, cents: c }) => ({ vat, cents: c }));
+}
+const FUENF = ['amountRateStandard', 'amountRateReduced1', 'amountRateReduced2', 'amountRateZero', 'amountRateSpecial'];
+/** `vat-buckets.bucketFuerSatz`. */
+function topfFuerSatz(vat) {
+    switch (vat) {
+        case 20: return 'amountRateStandard';
+        case 10: return 'amountRateReduced1';
+        case 13: return 'amountRateReduced2';
+        case 0: return 'amountRateZero';
+        case 19: return 'amountRateSpecial';
+        case 4.9: return 'amountRateSpecial';
+        default: return 'amountRatOthers';
+    }
+}
+/** `beleg-toepfe.belegToepfe`, Schritt fuer Schritt. */
+function belegToepfe(positionen, gutscheine) {
+    const t = { amountRateStandard: 0, amountRateReduced1: 0, amountRateReduced2: 0, amountRateZero: 0, amountRateSpecial: 0, amountRatOthers: 0 };
+    let personal = 0;
+    for (const p of positionen) {
+        if (p.tip === 'staff')
+            personal += p.amount * p.priceOne;
+        else
+            t[topfFuerSatz(p.vat)] += p.priceOne * p.amount;
+    }
+    const gesamt = t.amountRateStandard + t.amountRateReduced1 + t.amountRateReduced2 + t.amountRateZero + t.amountRateSpecial;
+    if (gutscheine.length > 0) {
+        let rabatt = 0;
+        for (const v of gutscheine)
+            if (v.action === VoucherAction.redeem && v.type === VoucherType.promo)
+                rabatt += v.value;
+        const nutzbarCents = euroToCent(rabatt > gesamt ? gesamt : rabatt);
+        const cents = FUENF.map((n) => euroToCent(t[n]));
+        const basis = cents.reduce((s, c) => s + c, 0);
+        const anteil = cents.map(() => 0);
+        if (basis > 0 && nutzbarCents > 0) {
+            cents.forEach((c, i) => {
+                anteil[i] = Math.floor((nutzbarCents * c) / basis);
+            });
+            const rest = nutzbarCents - anteil.reduce((s, a) => s + a, 0);
+            if (rest > 0) {
+                // Groesster Topf; stabile Sortierung, bei Gleichstand der erste.
+                let groesster = 0;
+                for (let i = 1; i < cents.length; i++)
+                    if (cents[i] > cents[groesster])
+                        groesster = i;
+                if (cents[groesster] > 0)
+                    anteil[groesster] = anteil[groesster] + rest;
+            }
+        }
+        FUENF.forEach((n, i) => {
+            t[n] = (cents[i] - anteil[i]) / 100;
+        });
+    }
+    t.amountRateZero += personal;
+    const zaehlerDeltaCents = euroToCent(t.amountRateStandard) + euroToCent(t.amountRateReduced1) + euroToCent(t.amountRateReduced2) +
+        euroToCent(t.amountRateZero) + euroToCent(t.amountRateSpecial) + euroToCent(t.amountRatOthers);
+    return { ...t, zaehlerDeltaCents };
+}
+/** `zahlungen-core.wertgutscheinFlussCents`. */
+function wertgutscheinFlussCents(gutscheine, art) {
+    const vz = art === 'cancellation' ? -1 : 1;
+    let cents = 0;
+    for (const v of gutscheine) {
+        if (v.type !== VoucherType.value || !Number.isFinite(v.value))
+            continue;
+        const c = euroToCent(v.value);
+        if (v.action === VoucherAction.sell)
+            cents += c;
+        else if (v.action === VoucherAction.redeem)
+            cents -= c;
+    }
+    return vz * cents + 0;
+}

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

@@ -1,7 +1,7 @@
 import type { ReceiptLayout } from './layout.js';
 import type { PosPaperSize } from '../printing/escpos.js';
-import { type QrModulGroesse, type RasterBild } from '../printing/index.js';
-import { type DruckLogo } from './layout-escpos.js';
+import { type QrModuleSize, type RasterImage } from '../printing/index.js';
+import { type PrintLogo } 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
@@ -15,44 +15,44 @@ import { type DruckLogo } from './layout-escpos.js';
  */
 export interface EposPrintXmlOptions {
     /** Zeichen je Zeile; Vorgabe nach `layout.paperSize` (32/48). */
-    zeichen?: number;
+    charsPerLine?: number;
     /**
      * **Feste** QR-Modulgroesse (Epson `width` 3..16). Gesetzt schaltet sie die
      * Rechnung ab -- dann passt der Aufrufer selbst auf, dass das Symbol samt
      * Ruhezone auf die Rolle geht.
      */
-    qrBreite?: number;
+    qrWidth?: number;
     /**
      * Deckel fuer die gerechnete QR-Modulgroesse; Vorgabe `auto` (hoechstens 6
      * Punkte je Modul) -- wie ESC/POS, Blatt und der Flutter-Zwilling.
      *
-     * Bis 0.13 stand hier `mittel`, weil `auto` damals beim ESC/POS-Wert 4
+     * Bis 0.13 stand hier `mittel` (heute `medium`), 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;
+    qrModuleSize?: QrModuleSize;
     /** Papierschnitt am Ende, Vorgabe true. */
     cut?: boolean;
     /** Firmenlogo; ohne Angabe kein Logo. */
-    logo?: DruckLogo | null;
+    logo?: PrintLogo | null;
     /** Das Kasseneck-Logo am Ende (Konto-Flag `kreiseck_logo`). */
-    marke?: boolean;
+    brandMark?: boolean;
 }
 /**
  * Das XML **samt** dem, was dem QR unterwegs zugestossen ist -- dieselbe
- * Buchfuehrung wie `EscPosLayoutErgebnis` am ESC/POS-Weg.
+ * Buchfuehrung wie `EscPosLayoutResult` am ESC/POS-Weg.
  */
-export interface EposPrintErgebnis {
+export interface EposPrintResult {
     xml: string;
     /** Der Beleg ging ohne QR hinaus; das Symbol passt auch mit 3 Punkten nicht. */
-    qrFehler: string | null;
+    qrError: string | null;
     /** Der QR steht da, aber unter der Mindest-Modulgroesse. */
-    qrAusweich: string | null;
+    qrFallback: 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 eposImageXml(image: RasterImage): string;
+/** Nur das XML; wer die QR-Meldungen braucht, nimmt [eposPrintXmlResult]. */
 export declare function eposPrintXml(layout: ReceiptLayout, options?: EposPrintXmlOptions): string;
 /**
  * Wie [eposPrintXml], gibt aber zusaetzlich zurueck, was dem QR zugestossen
@@ -64,7 +64,7 @@ export declare function eposPrintXml(layout: ReceiptLayout, options?: EposPrintX
  * 58-mm-Kopf hat 384. Der Epson schneidet ein zu breites Symbol nicht ab, er
  * laesst es weg; genau daran fehlte am echten Beleg der QR.
  */
-export declare function eposPrintXmlErgebnis(layout: ReceiptLayout, options?: EposPrintXmlOptions): EposPrintErgebnis;
+export declare function eposPrintXmlResult(layout: ReceiptLayout, options?: EposPrintXmlOptions): EposPrintResult;
 /**
  * Epson-Drucker mit ePOS-Print direkt aus dem Browser ansprechen (ohne
  * Server-Umweg): POST an `https://<ip>/cgi-bin/epos/service.cgi`. Der Drucker
@@ -79,15 +79,15 @@ export interface EposDirectOptions {
     /** ePOS Device ID (Druckermenue), Vorgabe `local_printer`. */
     devid?: string;
     /** Papier des Druckers -- bestimmt das Raster; Vorgabe: das des Layouts. */
-    papier?: PosPaperSize;
-    /** Feste QR-Modulgroesse; siehe [EposPrintXmlOptions.qrBreite]. */
-    qrBreite?: number;
-    /** Deckel fuer die gerechnete QR-Modulgroesse; siehe [EposPrintXmlOptions.qrGroesse]. */
-    qrGroesse?: QrModulGroesse;
+    paperSize?: PosPaperSize;
+    /** Feste QR-Modulgroesse; siehe [EposPrintXmlOptions.qrWidth]. */
+    qrWidth?: number;
+    /** Deckel fuer die gerechnete QR-Modulgroesse; siehe [EposPrintXmlOptions.qrModuleSize]. */
+    qrModuleSize?: QrModuleSize;
     /** Firmenlogo; ohne Angabe kein Logo. */
-    logo?: DruckLogo | null;
+    logo?: PrintLogo | null;
     /** Das Kasseneck-Logo am Ende (Konto-Flag `kreiseck_logo`). */
-    marke?: boolean;
+    brandMark?: boolean;
     timeoutMs?: number;
 }
 export interface EposResponse {

package/dist/esm/receipt/epos.js

@@ -1,19 +1,19 @@
-import { QR_DRUCK_PUNKTE, QR_MINDEST_PUNKTE, QR_MODUL_DECKEL, qrGroesseFuer, qrPasstInVersion, rasterZeilenBase64, } from '../printing/index.js';
-import { ZEICHEN_JE_PAPIER } from './grid.js';
-import { papierFuerZeichen } from './blatt.js';
+import { QR_PRINT_WIDTH_DOTS, QR_MIN_MODULE_DOTS, QR_MODULE_SIZE_CAP, qrSizingFor, qrFitsInVersion, rasterRowsBase64, } from '../printing/index.js';
+import { CHARS_PER_PAPER_SIZE } from './grid.js';
+import { paperSizeForChars } from './blatt.js';
 import { blattFuerDruck } from './layout-escpos.js';
-import { markeBild } from './marke.js';
+import { brandMarkImage } from './marke.js';
 export 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). */
-export function eposBildXml(bild) {
-    return `<image width="${bild.breite}" height="${bild.hoehe}" color="color_1" mode="mono">${rasterZeilenBase64(bild)}</image>`;
+export function eposImageXml(image) {
+    return `<image width="${image.width}" height="${image.height}" color="color_1" mode="mono">${rasterRowsBase64(image)}</image>`;
 }
 const NS = 'http://www.epson-pos.com/schemas/2011/03/epos-print';
-/** Nur das XML; wer die QR-Meldungen braucht, nimmt [eposPrintXmlErgebnis]. */
+/** Nur das XML; wer die QR-Meldungen braucht, nimmt [eposPrintXmlResult]. */
 export function eposPrintXml(layout, options = {}) {
-    return eposPrintXmlErgebnis(layout, options).xml;
+    return eposPrintXmlResult(layout, options).xml;
 }
 /**
  * Wie [eposPrintXml], gibt aber zusaetzlich zurueck, was dem QR zugestossen
@@ -25,14 +25,14 @@ export function eposPrintXml(layout, options = {}) {
  * 58-mm-Kopf hat 384. Der Epson schneidet ein zu breites Symbol nicht ab, er
  * laesst es weg; genau daran fehlte am echten Beleg der QR.
  */
-export function eposPrintXmlErgebnis(layout, options = {}) {
-    const zeichen = options.zeichen ?? ZEICHEN_JE_PAPIER[layout.paperSize];
-    const papier = papierFuerZeichen(zeichen, layout.paperSize);
-    const deckel = options.qrGroesse ?? 'auto';
-    const blatt = blattFuerDruck(layout, { zeichen, logo: options.logo, marke: options.marke, qrGroesse: deckel });
-    const fest = options.qrBreite === undefined
+export function eposPrintXmlResult(layout, options = {}) {
+    const zeichen = options.charsPerLine ?? CHARS_PER_PAPER_SIZE[layout.paperSize];
+    const papier = paperSizeForChars(zeichen, layout.paperSize);
+    const deckel = options.qrModuleSize ?? 'auto';
+    const blatt = blattFuerDruck(layout, { zeichen, logo: options.logo, marke: options.brandMark, qrGroesse: deckel });
+    const fest = options.qrWidth === undefined
         ? null
-        : Math.min(16, Math.max(3, Math.floor(options.qrBreite)));
+        : Math.min(16, Math.max(3, Math.floor(options.qrWidth)));
     let qrFehler = null;
     let qrAusweich = null;
     /**
@@ -47,30 +47,30 @@ export function eposPrintXmlErgebnis(layout, options = {}) {
         if (fest !== null)
             return fest;
         if (nutzlast === '')
-            return QR_MODUL_DECKEL[deckel];
+            return QR_MODULE_SIZE_CAP[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 (!qrPasstInVersion(nutzlast)) {
+        if (!qrFitsInVersion(nutzlast)) {
             qrFehler = 'QR-Inhalt passt in keine QR-Version -- Beleg ohne QR';
             return null;
         }
-        const mass = qrGroesseFuer({
-            nutzlast,
-            papierbreitePunkte: QR_DRUCK_PUNKTE[layout.paperSize],
-            groesse: deckel,
+        const mass = qrSizingFor({
+            payload: nutzlast,
+            paperWidthDots: QR_PRINT_WIDTH_DOTS[layout.paperSize],
+            moduleSize: deckel,
         });
-        if (!mass.passt) {
+        if (!mass.fits) {
             qrFehler =
-                `QR mit ${mass.module} Modulen ist fuer ${layout.paperSize === 'mm58' ? 58 : 80} mm ` +
-                    `(${QR_DRUCK_PUNKTE[layout.paperSize]} Punkte) zu breit`;
+                `QR mit ${mass.modules} Modulen ist fuer ${layout.paperSize === 'mm58' ? 58 : 80} mm ` +
+                    `(${QR_PRINT_WIDTH_DOTS[layout.paperSize]} Punkte) zu breit`;
             return null;
         }
-        if (mass.unterMindestmass) {
+        if (mass.belowMinimum) {
             qrAusweich =
-                `QR mit ${mass.module} Modulen passt nur mit ${String(mass.punkte)} Punkten ` +
-                    `je Modul -- unter dem Mindestmass von ${QR_MINDEST_PUNKTE}`;
+                `QR mit ${mass.modules} Modulen passt nur mit ${String(mass.moduleDots)} Punkten ` +
+                    `je Modul -- unter dem Mindestmass von ${QR_MIN_MODULE_DOTS}`;
         }
-        return mass.punkte;
+        return mass.moduleDots;
     };
     const out = [];
     out.push(`<epos-print xmlns="${NS}">`);
@@ -78,12 +78,12 @@ export 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 block of blatt.bloecke) {
-        switch (block.art) {
-            case 'zeile':
-                if (block.leer)
+    for (const block of blatt.blocks) {
+        switch (block.kind) {
+            case 'line':
+                if (block.blank)
                     out.push('<feed line="1"/>');
-                else if (block.fett) {
+                else if (block.bold) {
                     out.push(`<text em="true">${eposXmlEscape(block.text)}&#10;</text>`);
                     out.push('<text em="false"/>');
                 }
@@ -93,21 +93,21 @@ export function eposPrintXmlErgebnis(layout, options = {}) {
             case 'logo':
                 if (options.logo) {
                     out.push('<text align="center"/>');
-                    out.push(eposBildXml(options.logo.raster));
+                    out.push(eposImageXml(options.logo.raster));
                     out.push('<text align="left"/>');
                 }
                 break;
-            case 'marke':
+            case 'brandMark':
                 out.push('<text align="center"/>');
-                out.push(eposBildXml(markeBild(papier)));
+                out.push(eposImageXml(brandMarkImage(papier)));
                 out.push('<text align="left"/>');
                 break;
             case 'qr': {
-                const breite = qrBreiteFuer(block.nutzlast);
+                const breite = qrBreiteFuer(block.payload);
                 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(block.nutzlast)}</symbol>`);
+                out.push(`<symbol type="qrcode_model_2" level="level_m" width="${breite}" height="0" size="0">${eposXmlEscape(block.payload)}</symbol>`);
                 out.push('<text align="left"/>');
                 break;
             }
@@ -118,7 +118,7 @@ export function eposPrintXmlErgebnis(layout, options = {}) {
         out.push('<cut type="feed"/>');
     }
     out.push('</epos-print>');
-    return { xml: out.join('\n'), qrFehler, qrAusweich };
+    return { xml: out.join('\n'), qrError: qrFehler, qrFallback: qrAusweich };
 }
 const EPOS_DEVID_VORGABE = 'local_printer';
 export function eposServiceUrl(ip, devid = EPOS_DEVID_VORGABE, timeoutMs = 10000) {
@@ -224,16 +224,16 @@ async function eposDirectSend(innerXml, o, fetchFn) {
 }
 /** Beleg direkt drucken; wirft bei Netz-/Zertifikatsproblemen, sonst die Drucker-Antwort. */
 export function eposDirectPrint(layout, o, fetchFn = fetch) {
-    const papier = o.papier ?? layout.paperSize;
-    const xmlOptionen = { zeichen: ZEICHEN_JE_PAPIER[papier] };
-    if (o.qrBreite !== undefined)
-        xmlOptionen.qrBreite = o.qrBreite;
-    if (o.qrGroesse !== undefined)
-        xmlOptionen.qrGroesse = o.qrGroesse;
+    const papier = o.paperSize ?? layout.paperSize;
+    const xmlOptionen = { charsPerLine: CHARS_PER_PAPER_SIZE[papier] };
+    if (o.qrWidth !== undefined)
+        xmlOptionen.qrWidth = o.qrWidth;
+    if (o.qrModuleSize !== undefined)
+        xmlOptionen.qrModuleSize = o.qrModuleSize;
     if (o.logo)
         xmlOptionen.logo = o.logo;
-    if (o.marke !== undefined)
-        xmlOptionen.marke = o.marke;
+    if (o.brandMark !== undefined)
+        xmlOptionen.brandMark = o.brandMark;
     return eposDirectSend(eposPrintXml({ ...layout, paperSize: papier }, xmlOptionen), o, fetchFn);
 }
 /** Verbindungstest: leeres Dokument, druckt nichts, liefert den Druckerstatus. */

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

@@ -1,4 +1,4 @@
-import type { ReceiptLayout } from './layout.js';
+import type { LayoutBannerTone, ReceiptLayout } from './layout.js';
 import type { PosPaperSize } from '../printing/escpos.js';
 /**
  * Zeichenraster: der Beleg als Zeilen mit **exakt N Zeichen** -- die einzige
@@ -11,7 +11,7 @@ import type { PosPaperSize } from '../printing/escpos.js';
  *   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`,
+ * - Text/Aufdruck/Spalteninhalt bricht **wortweise** um (`wrapText`,
  *   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
@@ -20,28 +20,28 @@ import type { PosPaperSize } from '../printing/escpos.js';
  * - 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 declare const CHARS_PER_PAPER_SIZE: Readonly<Record<PosPaperSize, number>>;
 export type GridLineKind = 'text' | 'columns' | 'rule' | 'space' | 'qr' | 'banner';
 export interface GridLine {
-    /** Genau `zeichen` Zeichen (bei `qr`: zentrierter Platzhalter). */
+    /** Genau `charsPerLine` Zeichen (bei `qr`: zentrierter Platzhalter). */
     text: string;
     kind: GridLineKind;
     bold: boolean;
-    /** Bei `banner` (Rahmen- und Textzeilen): `warnung` = Test/Ausfall, `belegart` = Storno, Nullbeleg … */
-    ton?: 'belegart' | 'warnung';
+    /** Bei `banner` (Rahmen- und Textzeilen): `warning` = Testkasse/Testsignatur, `receipt_type` = Storno, Nullbeleg … */
+    tone?: LayoutBannerTone;
     /** Bei `qr`: die Nutzlast. */
     qr?: string;
 }
 export interface ReceiptGrid {
     lines: GridLine[];
-    zeichen: number;
+    charsPerLine: number;
 }
 export interface RenderReceiptGridOptions {
     /** Zeichen je Zeile; Vorgabe nach `layout.paperSize` (32/48). */
-    zeichen?: number;
+    charsPerLine?: 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 gridColumnWidths(twelfths: readonly number[], chars: 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;
+export declare function gridToText(grid: ReceiptGrid): string;