@kreiseck/kasseneck-api 0.30.0 → 1.0.0-rc.1

package/dist/cjs/receipt/bild.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.logoRaster = logoRaster;
+exports.rasterizeLogo = rasterizeLogo;
 const blatt_js_1 = require("./blatt.js");
 /**
  * RGBA-Pixel (wie `ImageData.data` im Browser oder ein dekodiertes PNG in
@@ -8,30 +8,30 @@ const blatt_js_1 = require("./blatt.js");
  * dem Logo gibt.
  *
  * Die Rechnung ist Vertrag und hat einen Dart-Zwilling (Golden
- * `erwartet/logo-probe.raster32.txt`): Flaechenmittel je Druckpunkt,
+ * `expected/logo-sample.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) {
+function rasterizeLogo(rgba, pxWidth, pxHeight, dimensions, chars) {
+    if (!Number.isInteger(pxWidth) || !Number.isInteger(pxHeight) || pxWidth < 1 || pxHeight < 1 || rgba.length !== pxWidth * pxHeight * 4) {
         throw new Error('RGBA-Laenge passt nicht zum Pixelmass');
     }
-    const { breite, hoehe } = (0, blatt_js_1.logoRasterMass)(mass, zeichen);
+    const { width: breite, height: hoehe } = (0, blatt_js_1.logoRasterSize)(dimensions, chars);
     const grau = new Float64Array(breite * hoehe);
-    const sx = pxBreite / breite;
-    const sy = pxHoehe / hoehe;
+    const sx = pxWidth / breite;
+    const sy = pxHeight / 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)));
+        const y1 = Math.min(pxHeight, 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)));
+            const x1 = Math.min(pxWidth, 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 i = (py * pxWidth + 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);
@@ -61,5 +61,5 @@ function logoRaster(rgba, pxBreite, pxHoehe, mass, zeichen) {
             }
         }
     }
-    return { breite, hoehe, punkte };
+    return { width: breite, height: hoehe, dots: punkte };
 }

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

@@ -1,5 +1,5 @@
 import type { PosPaperSize } from '../printing/escpos.js';
-import { type QrModulGroesse } from '../printing/index.js';
+import { type QrModuleSize } from '../printing/index.js';
 import type { ReceiptLayout } from './layout.js';
 /**
  * Das Beleg-Blatt: die vollstaendige Folge dessen, was auf dem Papier steht --
@@ -15,85 +15,85 @@ import type { ReceiptLayout } from './layout.js';
  * Punkte breit, eine Zeile 24 Punkte hoch. Am Bildschirm ist eine Zeile `2ch`,
  * im PDF zwei Zeichenbreiten.
  */
-export type LogoStufe = 'S' | 'M' | 'L' | 'XL';
+export type SheetLogoSize = '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 SHEET_LOGO_SIZES: Readonly<Record<SheetLogoSize, {
+    readonly widthFraction: number;
+    readonly heightLines: number;
 }>>;
-export declare const PUNKTE_JE_ZEICHEN = 12;
-export declare const PUNKTE_JE_ZEILE = 24;
-export interface BlattLogo {
-    stufe: LogoStufe;
+export declare const DOTS_PER_CHAR = 12;
+export declare const DOTS_PER_LINE = 24;
+export interface SheetLogo {
+    size: SheetLogoSize;
     /** Pixelmass des Originalbilds -- ohne das laesst sich nicht einpassen. */
-    pxBreite: number;
-    pxHoehe: number;
+    pixelWidth: number;
+    pixelHeight: number;
 }
-export interface LogoMass {
+export interface LogoDimensions {
     /** Anteil der Blattbreite (0..1). */
-    breiteAnteil: number;
+    widthFraction: number;
     /** Hoehe in Zeilen (nicht ganzzahlig). */
-    hoeheZeilen: number;
+    heightLines: number;
 }
-export type BlattBlock = {
-    readonly art: 'zeile';
+export type SheetBlock = {
+    readonly kind: 'line';
     readonly text: string;
-    readonly fett: boolean;
-    readonly leer: boolean;
+    readonly bold: boolean;
+    readonly blank: boolean;
 } | {
-    readonly art: 'logo';
-    readonly breiteAnteil: number;
-    readonly hoeheZeilen: number;
+    readonly kind: 'logo';
+    readonly widthFraction: number;
+    readonly heightLines: number;
 } | {
-    readonly art: 'qr';
-    readonly nutzlast: string;
-    readonly breiteAnteil: number;
+    readonly kind: 'qr';
+    readonly payload: string;
+    readonly widthFraction: number;
 } | {
-    readonly art: 'marke';
-    readonly breite: number;
-    readonly hoehe: number;
+    readonly kind: 'brandMark';
+    readonly width: number;
+    readonly height: number;
 };
-export interface BelegBlatt {
-    readonly zeichen: number;
-    readonly bloecke: readonly BlattBlock[];
+export interface ReceiptSheet {
+    readonly charsPerLine: number;
+    readonly blocks: readonly SheetBlock[];
 }
-export interface BelegBlattOptionen {
+export interface ReceiptSheetOptions {
     /** Zeichen je Zeile; Vorgabe nach `layout.paperSize` (32/48). */
-    zeichen?: number;
+    charsPerLine?: number;
     /** Firmenlogo; ohne Angabe kein Logo-Block. */
-    logo?: BlattLogo | null;
+    logo?: SheetLogo | null;
     /** Das Kasseneck-Logo am Ende (Konto-Flag `kreiseck_logo`). */
-    marke?: boolean;
+    brandMark?: boolean;
     /** Geraete-Einstellung fuer die QR-Modulgroesse; Vorgabe `auto` (hoechstens 6 Punkte je Modul) — wie die Druckwege. */
-    qrGroesse?: QrModulGroesse;
+    qrModuleSize?: QrModuleSize;
 }
 /**
  * 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
+ * Layouts. Der QR-Anteil (`qrSheetWidthFraction`) wird dann fuer die Kopfbreite
  * DIESES Papiers gerechnet, nicht fuer die gewaehlte Zeichenzahl.
  */
-export declare function papierFuerZeichen(zeichen: number, vorgabe: PosPaperSize): PosPaperSize;
+export declare function paperSizeForChars(chars: number, fallback: 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`):
+ * dieselbe Grenze wie im Druck-Kit (`LOGO_MAX_PIXELS` 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;
+export declare const LOGO_MAX_PIXELS = 4096;
 /** Reine Pruefung, ob ein Logo dieser Pixelmasse noch angezeigt/gedruckt werden darf. */
-export declare function logoPixelZulaessig(breite: number, hoehe: number): boolean;
+export declare function isLogoPixelSizeAllowed(width: number, height: 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;
+export declare function logoDimensions(logo: SheetLogo, chars: number): LogoDimensions;
 /** 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;
+export declare function logoRasterSize(dimensions: LogoDimensions, chars: number): {
+    width: number;
+    height: number;
 };
 /**
  * Anteil der Blattbreite, den der QR am Drucker einnimmt -- dieselbe Rechnung
@@ -105,5 +105,5 @@ export declare function logoRasterMass(mass: LogoMass, zeichen: number): {
  * 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;
+export declare function qrSheetWidthFraction(payload: string, paperSize: PosPaperSize, size?: QrModuleSize): number;
+export declare function receiptSheet(layout: ReceiptLayout, options?: ReceiptSheetOptions): ReceiptSheet;

package/dist/cjs/receipt/blatt.js

@@ -1,72 +1,72 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LOGO_PIXEL_MAX = 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;
+exports.LOGO_MAX_PIXELS = exports.DOTS_PER_LINE = exports.DOTS_PER_CHAR = exports.SHEET_LOGO_SIZES = void 0;
+exports.paperSizeForChars = paperSizeForChars;
+exports.isLogoPixelSizeAllowed = isLogoPixelSizeAllowed;
+exports.logoDimensions = logoDimensions;
+exports.logoRasterSize = logoRasterSize;
+exports.qrSheetWidthFraction = qrSheetWidthFraction;
+exports.receiptSheet = receiptSheet;
 const index_js_1 = require("../printing/index.js");
 const grid_js_1 = require("./grid.js");
 const marke_daten_js_1 = require("./marke-daten.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.SHEET_LOGO_SIZES = {
+    S: { widthFraction: 0.42, heightLines: 5 },
+    M: { widthFraction: 0.62, heightLines: 8 },
+    L: { widthFraction: 0.8, heightLines: 12 },
+    XL: { widthFraction: 0.94, heightLines: 16 },
 };
-exports.PUNKTE_JE_ZEICHEN = 12;
-exports.PUNKTE_JE_ZEILE = 24;
+exports.DOTS_PER_CHAR = 12;
+exports.DOTS_PER_LINE = 24;
 /**
  * 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
+ * Layouts. Der QR-Anteil (`qrSheetWidthFraction`) 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)
+function paperSizeForChars(chars, fallback) {
+    if (chars === grid_js_1.CHARS_PER_PAPER_SIZE.mm58)
         return 'mm58';
-    if (zeichen === grid_js_1.ZEICHEN_JE_PAPIER.mm80)
+    if (chars === grid_js_1.CHARS_PER_PAPER_SIZE.mm80)
         return 'mm80';
-    return vorgabe;
+    return fallback;
 }
 /**
  * Obergrenze der Logo-Pixel, die der Bildschirm noch anzeigen darf -- exakt
- * dieselbe Grenze wie im Druck-Kit (`LOGO_PIXEL_MAX` in `druck-logo.ts`):
+ * dieselbe Grenze wie im Druck-Kit (`LOGO_MAX_PIXELS` 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;
+exports.LOGO_MAX_PIXELS = 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;
+function isLogoPixelSizeAllowed(width, height) {
+    return width > 0 && height > 0 && width <= exports.LOGO_MAX_PIXELS && height <= exports.LOGO_MAX_PIXELS;
 }
 /**
  * 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))
+function logoDimensions(logo, chars) {
+    if (!(logo.pixelWidth > 0) || !(logo.pixelHeight > 0))
         throw new Error('Logo ohne Pixelmass');
-    const stufe = exports.LOGO_STUFEN[logo.stufe];
+    const stufe = exports.SHEET_LOGO_SIZES[logo.size];
     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);
+        throw new Error(`Unbekannte Logo-Stufe: ${String(logo.size)}`);
+    const blattPunkte = chars * exports.DOTS_PER_CHAR;
+    const faktor = Math.min((stufe.widthFraction * blattPunkte) / logo.pixelWidth, (stufe.heightLines * exports.DOTS_PER_LINE) / logo.pixelHeight, 1);
     return {
-        breiteAnteil: (logo.pxBreite * faktor) / blattPunkte,
-        hoeheZeilen: (logo.pxHoehe * faktor) / exports.PUNKTE_JE_ZEILE,
+        widthFraction: (logo.pixelWidth * faktor) / blattPunkte,
+        heightLines: (logo.pixelHeight * faktor) / exports.DOTS_PER_LINE,
     };
 }
 /** Das Mass in ganzen Druckpunkten -- so gross muss das Rasterbild fuer den Bon sein. */
-function logoRasterMass(mass, zeichen) {
+function logoRasterSize(dimensions, chars) {
     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)),
+        width: Math.max(1, Math.round(dimensions.widthFraction * chars * exports.DOTS_PER_CHAR)),
+        height: Math.max(1, Math.round(dimensions.heightLines * exports.DOTS_PER_LINE)),
     };
 }
 /**
@@ -79,35 +79,35 @@ function logoRasterMass(mass, zeichen) {
  * 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 === '')
+function qrSheetWidthFraction(payload, paperSize, size = 'auto') {
+    if (payload === '')
         return 0;
     // Ein Inhalt, der in keine QR-Version passt (Fehlerkorrektur M, hoechstens
-    // 2331 Byte), wuerde hier `qrGroesseFuer` -> `qrModulAnzahl` zum Werfen
+    // 2331 Byte), wuerde hier `qrSizingFor` -> `qrModuleCount` 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
+    // QR, statt gar nicht zu stehen. `qrModuleCount` selbst wirft weiter -- wer
     // es ausserhalb des Blatts aufruft, soll den Fehler sehen.
-    if (!(0, index_js_1.qrPasstInVersion)(nutzlast))
+    if (!(0, index_js_1.qrFitsInVersion)(payload))
         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;
+    const papierPunkte = index_js_1.QR_PRINT_WIDTH_DOTS[paperSize];
+    const mass = (0, index_js_1.qrSizingFor)({ payload: payload, paperWidthDots: papierPunkte, moduleSize: size });
+    if (mass.fits)
+        return mass.widthDots / papierPunkte;
+    return ((mass.modules + 2 * index_js_1.QR_QUIET_ZONE_MODULES) * (0, index_js_1.qrRasterDots)(paperSize, mass.modules, { moduleSize: size })) / papierPunkte;
 }
-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 };
+function receiptSheet(layout, options = {}) {
+    const grid = (0, grid_js_1.renderReceiptGrid)(layout, options.charsPerLine === undefined ? {} : { charsPerLine: options.charsPerLine });
+    const zeichen = grid.charsPerLine;
+    const papier = paperSizeForChars(zeichen, layout.paperSize);
+    const qrGroesse = options.qrModuleSize ?? 'auto';
+    const leerzeile = { kind: 'line', text: ' '.repeat(zeichen), bold: false, blank: 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' };
+        ? { kind: 'qr', payload: z.qr ?? '', widthFraction: qrSheetWidthFraction(z.qr ?? '', papier, qrGroesse) }
+        : { kind: 'line', text: z.text, bold: z.bold, blank: z.kind === 'space' };
     const bloecke = [];
     let i = 0;
-    if (optionen.logo) {
+    if (options.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') {
@@ -118,21 +118,21 @@ function belegBlatt(layout, optionen = {}) {
         // Rahmen oder an den Firmennamen kleben.
         if (i > 0)
             bloecke.push(leerzeile);
-        bloecke.push({ art: 'logo', ...logoMass(optionen.logo, zeichen) });
+        bloecke.push({ kind: 'logo', ...logoDimensions(options.logo, zeichen) });
         bloecke.push(leerzeile);
     }
     for (; i < grid.lines.length; i += 1)
         bloecke.push(block(grid.lines[i]));
-    if (optionen.marke === true) {
-        // Das Raster deckt nur die beiden bekannten Papierbreiten ab (`MARKE_RASTER`).
+    if (options.brandMark === true) {
+        // Das Raster deckt nur die beiden bekannten Papierbreiten ab (`BRAND_MARK_RASTERS`).
         // Faende sich hier eine dritte, faellt die Marke weg statt ein Raster in
         // falscher Groesse zu drucken -- derselbe Grundsatz wie beim Firmenlogo:
         // eine Marke ist Zierde, der Beleg ist Pflicht.
-        const raster = marke_daten_js_1.MARKE_RASTER[papier];
+        const raster = marke_daten_js_1.BRAND_MARK_RASTERS[papier];
         if (raster) {
             bloecke.push(leerzeile);
-            bloecke.push({ art: 'marke', breite: raster.breite, hoehe: raster.hoehe });
+            bloecke.push({ kind: 'brandMark', width: raster.width, height: raster.height });
         }
     }
-    return { zeichen, bloecke };
+    return { charsPerLine: zeichen, blocks: bloecke };
 }

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

@@ -9,4 +9,4 @@ import type { ReceiptItem } from '../models/receipt-item.js';
  * 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[];
+export declare function distributeDiscount(items: ReceiptItem[], discountCents: number, name?: string): ReceiptItem[];

package/dist/cjs/receipt/discount.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.verteileRabatt = verteileRabatt;
+exports.distributeDiscount = distributeDiscount;
 const receipt_item_js_1 = require("../models/receipt-item.js");
 /**
  * Rabatt als negative Position(en) — eine je Steuersatz, anteilig zum
@@ -12,15 +12,15 @@ const receipt_item_js_1 = require("../models/receipt-item.js");
  * Abrunden uebrig bleiben, gehen der Reihe nach an die Gruppen mit dem
  * groessten Bruchteil; keine Zeile ist je groesser als der Umsatz ihres Satzes.
  */
-function verteileRabatt(positionen, rabattCents, name = 'Rabatt') {
-    if (!Number.isInteger(rabattCents) || rabattCents < 0) {
+function distributeDiscount(items, discountCents, name = 'Rabatt') {
+    if (!Number.isInteger(discountCents) || discountCents < 0) {
         throw new Error('Rabatt muss eine ganze Zahl in Cent >= 0 sein');
     }
-    if (rabattCents === 0)
+    if (discountCents === 0)
         return [];
     // Umsatz je Steuersatz (nur positive Positionen -- Rabatte/Stornos zaehlen nicht mit)
     const gruppen = new Map();
-    for (const p of positionen) {
+    for (const p of items) {
         const betrag = (0, receipt_item_js_1.receiptItemTotalCents)(p);
         if (betrag <= 0)
             continue;
@@ -30,12 +30,12 @@ function verteileRabatt(positionen, rabattCents, name = 'Rabatt') {
         gruppen.set(key, g);
     }
     const gesamt = [...gruppen.values()].reduce((s, g) => s + g.umsatz, 0);
-    if (rabattCents > gesamt)
+    if (discountCents > gesamt)
         throw new Error('Rabatt uebersteigt den Umsatz');
     const liste = [...gruppen.values()];
-    const exakt = liste.map((g) => (rabattCents * g.umsatz) / gesamt);
+    const exakt = liste.map((g) => (discountCents * g.umsatz) / gesamt);
     const anteile = exakt.map((x) => Math.floor(x));
-    let rest = rabattCents - anteile.reduce((s, a) => s + a, 0);
+    let rest = discountCents - 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++) {

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

@@ -0,0 +1,86 @@
+import { ReceiptType, type ReceiptTypeKey, KeckPaymentMethod } from '../enums/index.js';
+import type { ReceiptItem } from '../models/receipt-item.js';
+import type { Voucher } from '../models/voucher.js';
+/**
+ * Zahlbetrag eines Belegs in ganzen Cent: Zwilling von `createReceipt` im
+ * Backend (Nachtrag §8), also `beleg-toepfe.belegToepfe(...).zaehlerDeltaCents`
+ * plus `zahlungen-core.wertgutscheinFlussCents`, mit den Trinkgeld-Positionen,
+ * die `tip-core.buildTipItems` aus `tip` bzw. aus `payments[].tipCents` baut.
+ *
+ * `createReceipt` hat keinen Probelauf. Unter `/v3` ist `payments[]` Pflicht,
+ * und die Summe der Zahlungen muss genau diesen Betrag treffen; wer die
+ * Zahlungen baut (Kartenterminal, Rueckgeld), rechnet ihn hier vorher aus.
+ * Trifft die Summe nicht, antwortet der Server mit `payments_sum_mismatch` und
+ * `expectedCents`, ohne eine Belegnummer zu verbrauchen; das Paket wiederholt
+ * nie selbst.
+ *
+ * **Bewusst dieselbe Rechnung wie der Server, nicht die exakte.** Das Backend
+ * rechnet die RKSV-Toepfe in Euro-Gleitkomma (Einzelpreis `Math.round(cents)/100`,
+ * je Topf `priceOne * amount` in Positionsreihenfolge, Trinkgeld-Positionen
+ * hinten angehaengt, gerundet mit `Math.round(euro * 100)`, Rabatt-Deckel in
+ * Euro). Diese Reihenfolge ist signiert und aendert sich nicht; ein exakter
+ * Zwilling wiche bei Bruchmengen auf halbem Cent ab (0,5 x 29 ct: Server 14,
+ * exakt 15). Darum steht hier dieselbe Arithmetik, Schritt fuer Schritt.
+ * Eingaben und Ergebnis sind ganze Cent; die Gleitkommazahlen leben nur
+ * innerhalb dieser Rechnung. Geprueft gegen die 20 Vertragsfaelle aus
+ * `fixtures/v3/zahlbetrag-faelle.json` und gegen mehr als 1000 mit dem echten
+ * Backend-Code erzeugte Faelle (`fixtures/receipt-due-generated.json`).
+ *
+ * **Trinkgeld-Empfaenger:** Ohne `recipients` bucht der Server das Trinkgeld
+ * auf den angemeldeten Kassen-Benutzer, und dessen Inhaber-Kennzeichen
+ * entscheidet: Inhaber-Trinkgeld ist Umsatz (anteilig auf die Saetze der Ware,
+ * mitrabattiert), Personal-Trinkgeld ein durchlaufender Posten (nie
+ * rabattiert). Das weiss nur die Kasse; darum ist `tipRecipient` Pflicht,
+ * sobald Trinkgeld ohne `recipients` vorkommt. Ohne angemeldeten Benutzer
+ * (Geraete-Schluessel) gilt `'staff'`.
+ */
+/** Wer das Trinkgeld ohne `recipients` bekommt (Kennzeichen des angemeldeten Kassen-Benutzers). */
+export type ReceiptDueTipRecipient = 'owner' | 'staff';
+/** Trinkgeld wie `tip` an `sellReceipt`: Betrag, optional mit Empfaengern samt Inhaber-Kennzeichen. */
+export type ReceiptDueTip = number | {
+    cents: number;
+    recipients?: ReadonlyArray<{
+        cents: number;
+        owner: boolean;
+    }>;
+};
+export interface ReceiptDueOptions {
+    /** Trinkgeld als Parameter `tip`; nie zugleich mit `payments[].tipCents` (`tip_conflict`). */
+    tip?: ReceiptDueTip;
+    /**
+     * Die Zahlungen, soweit sie Trinkgeld tragen (`tipCents`). Der Server bucht
+     * je Zahlart genau so, als waere `tip: { cents: Summe, paymentMethod }`
+     * geschickt worden. Andere Felder zaehlen hier nicht.
+     */
+    payments?: ReadonlyArray<{
+        method: KeckPaymentMethod | string;
+        tipCents?: number;
+    }>;
+    /** Pflicht, sobald Trinkgeld ohne `recipients` vorkommt (siehe Modulkommentar). */
+    tipRecipient?: ReceiptDueTipRecipient;
+}
+/** Die sechs RKSV-Toepfe in Cent, Namen wie am Beleg des Backends. */
+export interface ReceiptDueBuckets {
+    amountRateStandard: number;
+    amountRateReduced1: number;
+    amountRateReduced2: number;
+    amountRateZero: number;
+    amountRateSpecial: number;
+    amountRatOthers: number;
+}
+export interface ReceiptDueBreakdown {
+    /** Was die Zahlungen zusammen ergeben muessen. */
+    dueCents: number;
+    /** Delta des Umsatzzaehlers (Summe der Toepfe). */
+    counterDeltaCents: number;
+    /** Anteil der Wertgutscheine am Zahlbetrag. */
+    valueVoucherFlowCents: number;
+    /** Toepfe je auf Cent gerundet; `null` bei Start- und Nullbeleg. */
+    bucketsCents: ReceiptDueBuckets | null;
+}
+type BelegArt = ReceiptType | ReceiptTypeKey | string;
+/** Zahlbetrag in Cent, siehe Modulkommentar. */
+export declare function receiptDueCents(items: readonly ReceiptItem[], vouchers: readonly Voucher[], receiptType: BelegArt, options?: ReceiptDueOptions): number;
+/** Wie [receiptDueCents], dazu Zaehler-Delta, Wertgutschein-Anteil und Toepfe. */
+export declare function receiptDueBreakdown(items: readonly ReceiptItem[], vouchers: readonly Voucher[], receiptType: BelegArt, options?: ReceiptDueOptions): ReceiptDueBreakdown;
+export {};