@kreiseck/kasseneck-api 0.13.1 → 0.14.0

package/dist/cjs/printing/escpos.js

@@ -25,8 +25,9 @@
  * CP437-Plaetze umkodiert (ä = 0x84, ü = 0x81, ß = 0xE1, ...). Zeichen ohne
  * CP437-Platz werden zu `?` — weiterhin ein Byte je Zeichen.
  *
- * Nicht enthalten (bewusst): Rasterbilder/Logos, Capability-Profile einzelner
- * Druckermodelle, Kassenlade, 1D-Barcodes.
+ * Nicht enthalten (bewusst): Bilddekodierung (PNG/JPEG liest die Huelle),
+ * Capability-Profile einzelner Druckermodelle, Kassenlade, 1D-Barcodes.
+ * Fertige einfarbige Rasterbilder (Logo) gehen ueber [escPosRasterBild].
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.encodeEscPosText = encodeEscPosText;
@@ -49,6 +50,9 @@ exports.qrCodeBytes = qrCodeBytes;
 exports.escPosQrCode = escPosQrCode;
 exports.escPosQrRaster = escPosQrRaster;
 exports.qrRasterPunkte = qrRasterPunkte;
+exports.rasterZeilenBytes = rasterZeilenBytes;
+exports.rasterZeilenBase64 = rasterZeilenBase64;
+exports.escPosRasterBild = escPosRasterBild;
 const qr_groesse_js_1 = require("./qr-groesse.js");
 // -------------------------------------------------------------- Befehlsbytes
 // Wortwoertlich aus commands.dart. Die Zahlen sind ASCII-Codes der dortigen
@@ -603,13 +607,19 @@ function escPosRow(doc, columns) {
  * es wird kein Bild uebertragen.
  *
  * Bei Kasseneck-Belegen steht hier der maschinenlesbare RKSV-Code.
+ *
+ * Fehlerkorrektur ohne Angabe: **M** (bis 0.13: L). Die Groessenrechnung
+ * (`qrModulAnzahl`), das Blatt (Anteil am Bildschirm und im PDF), der
+ * ePOS-Weg (`level_m`) und der Bildweg rechnen alle mit M — druckte der
+ * native Befehl mit L, kaeme fuer manche Nutzlasten ein kleineres Symbol
+ * heraus als der Bildschirm zeigt.
  */
 function qrCodeBytes(text, options = {}) {
     const size = options.size ?? 4;
     if (!istGanzzahl(size) || size < 1 || size > 8) {
         throw new Error('QR-Modulgroesse muss eine Ganzzahl im Bereich 1..8 sein');
     }
-    const correction = options.correction ?? 'L';
+    const correction = options.correction ?? 'M';
     const stufe = QR_KORREKTUR[correction];
     if (stufe === undefined) {
         throw new Error(`Unbekannte QR-Fehlerkorrektur: ${String(correction)}`);
@@ -650,8 +660,8 @@ function qrCodeBytes(text, options = {}) {
  * **gerechneter** Modulgroesse, sofern `options.size` sie nicht festlegt.
  *
  * Ohne `size` entscheidet die Regel aus `qr-groesse.ts`: so gross wie
- * moeglich, gedeckelt durch `options.groesse` (Vorgabe `auto` = der
- * Bestandswert 4 dieses Pakets). Passt das Symbol auch mit der
+ * moeglich, gedeckelt durch `options.groesse` (Vorgabe `auto` = hoechstens 6
+ * Punkte je Modul, wie im Flutter-Zwilling). Passt das Symbol auch mit der
  * Ausnahmegroesse nicht aufs Papier, geht **kein** QR-Befehl hinaus und
  * `doc.qrFehler` sagt warum: der Drucker schneidet ein zu breites Symbol
  * nicht ab, er laesst es weg — ein Befehl, von dem man weiss, dass er nichts
@@ -736,9 +746,10 @@ function escPosQrRaster(doc, matrix, options = {}) {
     if (!istGanzzahl(punkte) || punkte < 1) {
         throw new Error('punkteJeModul muss eine Ganzzahl >= 1 sein');
     }
+    // Modulraster (samt Ruhezone) auf Druckpunkte skaliert -- dieselbe Bitquelle
+    // wie das Logo, nur aus einem QR-Modul-Bool statt aus Graustufen gewonnen.
     const breite = gesamtModule * punkte;
-    const byteJeZeile = Math.ceil(breite / 8);
-    const daten = new Uint8Array(byteJeZeile * breite);
+    const bildpunkte = new Uint8Array(breite * breite);
     for (let y = 0; y < breite; y++) {
         const modulY = Math.floor(y / punkte) - ruhezone;
         if (modulY < 0 || modulY >= module)
@@ -750,18 +761,14 @@ function escPosQrRaster(doc, matrix, options = {}) {
                 continue;
             if (zeile[modulX] !== true)
                 continue;
-            const i = y * byteJeZeile + (x >> 3);
-            daten[i] = daten[i] | (0x80 >> (x & 7));
+            bildpunkte[y * breite + x] = 1;
         }
     }
+    const daten = rasterZeilenBytes({ breite, hoehe: breite, punkte: bildpunkte });
     escPosSetStyles(doc, { align: options.align ?? 'center' });
     // GS v 0 m xL xH yL yH d1...dk — m = 0: normale Dichte, 1:1.
-    anhaengen(doc, [
-        GS, 0x76, 0x30, 0x00,
-        byteJeZeile & 0xff, (byteJeZeile >> 8) & 0xff,
-        breite & 0xff, (breite >> 8) & 0xff,
-        ...daten,
-    ]);
+    anhaengen(doc, rasterBildKopf(breite, breite));
+    anhaengen(doc, daten);
     anhaengen(doc, [ZEILENUMBRUCH]);
     if ((options.align ?? 'center') !== 'left') {
         escPosSetStyles(doc, { align: 'left' });
@@ -777,3 +784,68 @@ function qrRasterPunkte(paperSize, moduleAnzahl, options = {}) {
     const deckel = qr_groesse_js_1.QR_MODUL_DECKEL[options.groesse ?? 'auto'];
     return Math.max(1, Math.min(deckel, Math.floor(qr_groesse_js_1.QR_DRUCK_PUNKTE[paperSize] / (moduleAnzahl + 2 * ruhezone))));
 }
+/** Die Rasterzeilen als Bytes: MSB zuerst, jede Zeile auf volle Bytes aufgefuellt. */
+function rasterZeilenBytes(bild) {
+    if (!istGanzzahl(bild.breite) || bild.breite < 1 || !istGanzzahl(bild.hoehe) || bild.hoehe < 1) {
+        throw new Error('Rasterbild ohne gueltiges Mass');
+    }
+    if (bild.punkte.length !== bild.breite * bild.hoehe)
+        throw new Error('Rasterbild: Punkte passen nicht zum Mass');
+    const byteJeZeile = Math.ceil(bild.breite / 8);
+    const daten = new Uint8Array(byteJeZeile * bild.hoehe);
+    for (let y = 0; y < bild.hoehe; y++) {
+        for (let x = 0; x < bild.breite; x++) {
+            if (bild.punkte[y * bild.breite + x] !== 1)
+                continue;
+            const i = y * byteJeZeile + (x >> 3);
+            daten[i] = daten[i] | (0x80 >> (x & 7));
+        }
+    }
+    return daten;
+}
+/**
+ * Die Rasterzeilen als Base64 -- ohne Buffer, laeuft im Browser und in Node.
+ * Eine Stelle fuer ePOS-`<image>` und den Druckjob an den Server.
+ */
+function rasterZeilenBase64(bild) {
+    const bytes = rasterZeilenBytes(bild);
+    let binaer = '';
+    for (let i = 0; i < bytes.length; i += 0x8000) {
+        binaer += String.fromCharCode(...bytes.subarray(i, i + 0x8000));
+    }
+    return btoa(binaer);
+}
+/**
+ * Der `GS v 0`-Kopf (Byte-Breite, Zeilenhoehe) -- die Rasterzeilen selbst
+ * haengt der Aufrufer an. Gemeinsame Rahmung fuer das Logo (`escPosRasterBild`)
+ * und den QR-Bildweg (`escPosQrRaster`): beide drucken dasselbe Bildkommando,
+ * nur mit unterschiedlichem Nachlauf (Zeilenvorschub ja/nein).
+ */
+function rasterBildKopf(breite, hoehe) {
+    const byteJeZeile = Math.ceil(breite / 8);
+    return [GS, 0x76, 0x30, 0x00, byteJeZeile & 0xff, (byteJeZeile >> 8) & 0xff, hoehe & 0xff, (hoehe >> 8) & 0xff];
+}
+/**
+ * Ein Rasterbild (`GS v 0`) -- das Firmenlogo am Bon.
+ *
+ * Anders als `escPosQrRaster` folgt KEIN Zeilenvorschub: `GS v 0` schiebt das
+ * Papier um die Bildhoehe, ein LF danach waere eine zusaetzliche Leerzeile,
+ * die Bildschirm und PDF nicht haben. Die Luft um das Logo kommt aus dem Blatt.
+ */
+function escPosRasterBild(doc, bild, options = {}) {
+    // Masse pruefen, BEVOR gepackt wird: ein zu breites Bild soll nicht erst
+    // Speicher fuer seine Rasterzeilen belegen. `GS v 0` traegt die Hoehe in zwei
+    // Bytes (yL yH) -- ueber 65535 Punkte liefe sie still ueber und der Drucker
+    // laese den Rest des Bilds als Befehle.
+    if (bild.breite > qr_groesse_js_1.QR_DRUCK_PUNKTE[doc.paperSize])
+        throw new Error('Rasterbild breiter als der Druckkopf');
+    if (bild.hoehe > 0xffff)
+        throw new Error('Rasterbild hoeher als 65535 Punkte');
+    const daten = rasterZeilenBytes(bild);
+    escPosSetStyles(doc, { align: options.align ?? 'center' });
+    anhaengen(doc, rasterBildKopf(bild.breite, bild.hoehe));
+    anhaengen(doc, daten);
+    if ((options.align ?? 'center') !== 'left') {
+        escPosSetStyles(doc, { align: 'left' });
+    }
+}

package/dist/cjs/printing/index.d.ts

@@ -1,4 +1,4 @@
-export { type PosPaperSize, type PosAlign, type PosFont, type PosCutMode, type PosCodeTable, type PosTextSize, type QrSize, type QrCorrection, type QrMatrix, type PosStyles, type PosColumn, type EscPosOptions, type EscPosTextOptions, type EscPosHrOptions, type EscPosQrOptions, type EscPosQrRasterOptions, type EscPosDocument, createEscPosDocument, escPosBytes, escPosReset, escPosSetGlobalCodeTable, escPosSetGlobalFont, escPosSetStyles, escPosText, escPosEmptyLines, escPosFeed, escPosCut, escPosHr, escPosRow, escPosQrCode, escPosQrRaster, qrRasterPunkte, encodeEscPosText, qrCodeBytes, escPosMaxCharsPerLine, escPosWortzeilen, wortzeilenText, } from './escpos.js';
-export { type QrModulGroesse, type QrGroesse, QR_MODUL_DECKEL, QR_RUHEZONE_MODULE, QR_MINDEST_PUNKTE, QR_AUSNAHME_PUNKTE, QR_HOECHST_PUNKTE, QR_DRUCK_PUNKTE, qrModulAnzahl, qrGroesseBerechnen, qrGroesseFuer, } from './qr-groesse.js';
+export { type PosPaperSize, type PosAlign, type PosFont, type PosCutMode, type PosCodeTable, type PosTextSize, type QrSize, type QrCorrection, type QrMatrix, type PosStyles, type PosColumn, type EscPosOptions, type EscPosTextOptions, type EscPosHrOptions, type EscPosQrOptions, type EscPosQrRasterOptions, type EscPosDocument, createEscPosDocument, escPosBytes, escPosReset, escPosSetGlobalCodeTable, escPosSetGlobalFont, escPosSetStyles, escPosText, escPosEmptyLines, escPosFeed, escPosCut, escPosHr, escPosRow, escPosQrCode, escPosQrRaster, qrRasterPunkte, type RasterBild, rasterZeilenBytes, rasterZeilenBase64, escPosRasterBild, encodeEscPosText, qrCodeBytes, escPosMaxCharsPerLine, escPosWortzeilen, wortzeilenText, } from './escpos.js';
+export { type QrModulGroesse, type QrGroesse, QR_MODUL_DECKEL, QR_RUHEZONE_MODULE, QR_MINDEST_PUNKTE, QR_AUSNAHME_PUNKTE, QR_HOECHST_PUNKTE, QR_DRUCK_PUNKTE, qrModulAnzahl, qrPasstInVersion, qrGroesseBerechnen, qrGroesseFuer, } from './qr-groesse.js';
 export { escPosPrintableText } from './printable.js';
 export { type UsbEndpointLike, type UsbAlternateLike, type UsbInterfaceLike, type UsbConfigurationLike, type UsbTransferOutResultLike, type UsbWriterLike, type UsbIdentityLike, type UsbDeviceLike, type UsbPrinterEndpoint, type UsbPrinterConnection, USB_VENDOR_EPSON, USB_CLASS_PRINTER, UsbTimeoutError, usbDeviceKey, usbFindPrinterEndpoint, usbWriteAll, usbConnectPrinter, usbPrint, usbDisconnect, } from './webusb.js';

package/dist/cjs/printing/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.usbDisconnect = exports.usbPrint = exports.usbConnectPrinter = exports.usbWriteAll = exports.usbFindPrinterEndpoint = exports.usbDeviceKey = exports.UsbTimeoutError = exports.USB_CLASS_PRINTER = exports.USB_VENDOR_EPSON = exports.escPosPrintableText = exports.qrGroesseFuer = exports.qrGroesseBerechnen = exports.qrModulAnzahl = exports.QR_DRUCK_PUNKTE = exports.QR_HOECHST_PUNKTE = exports.QR_AUSNAHME_PUNKTE = exports.QR_MINDEST_PUNKTE = exports.QR_RUHEZONE_MODULE = exports.QR_MODUL_DECKEL = exports.wortzeilenText = exports.escPosWortzeilen = exports.escPosMaxCharsPerLine = exports.qrCodeBytes = exports.encodeEscPosText = exports.qrRasterPunkte = exports.escPosQrRaster = exports.escPosQrCode = exports.escPosRow = exports.escPosHr = exports.escPosCut = exports.escPosFeed = exports.escPosEmptyLines = exports.escPosText = exports.escPosSetStyles = exports.escPosSetGlobalFont = exports.escPosSetGlobalCodeTable = exports.escPosReset = exports.escPosBytes = exports.createEscPosDocument = void 0;
+exports.usbDisconnect = exports.usbPrint = exports.usbConnectPrinter = exports.usbWriteAll = exports.usbFindPrinterEndpoint = exports.usbDeviceKey = exports.UsbTimeoutError = exports.USB_CLASS_PRINTER = exports.USB_VENDOR_EPSON = exports.escPosPrintableText = exports.qrGroesseFuer = exports.qrGroesseBerechnen = exports.qrPasstInVersion = exports.qrModulAnzahl = exports.QR_DRUCK_PUNKTE = exports.QR_HOECHST_PUNKTE = exports.QR_AUSNAHME_PUNKTE = exports.QR_MINDEST_PUNKTE = exports.QR_RUHEZONE_MODULE = exports.QR_MODUL_DECKEL = exports.wortzeilenText = exports.escPosWortzeilen = exports.escPosMaxCharsPerLine = exports.qrCodeBytes = exports.encodeEscPosText = exports.escPosRasterBild = exports.rasterZeilenBase64 = exports.rasterZeilenBytes = exports.qrRasterPunkte = exports.escPosQrRaster = exports.escPosQrCode = exports.escPosRow = exports.escPosHr = exports.escPosCut = exports.escPosFeed = exports.escPosEmptyLines = exports.escPosText = exports.escPosSetStyles = exports.escPosSetGlobalFont = exports.escPosSetGlobalCodeTable = exports.escPosReset = exports.escPosBytes = exports.createEscPosDocument = void 0;
 var escpos_js_1 = require("./escpos.js");
 Object.defineProperty(exports, "createEscPosDocument", { enumerable: true, get: function () { return escpos_js_1.createEscPosDocument; } });
 Object.defineProperty(exports, "escPosBytes", { enumerable: true, get: function () { return escpos_js_1.escPosBytes; } });
@@ -17,6 +17,9 @@ Object.defineProperty(exports, "escPosRow", { enumerable: true, get: function ()
 Object.defineProperty(exports, "escPosQrCode", { enumerable: true, get: function () { return escpos_js_1.escPosQrCode; } });
 Object.defineProperty(exports, "escPosQrRaster", { enumerable: true, get: function () { return escpos_js_1.escPosQrRaster; } });
 Object.defineProperty(exports, "qrRasterPunkte", { enumerable: true, get: function () { return escpos_js_1.qrRasterPunkte; } });
+Object.defineProperty(exports, "rasterZeilenBytes", { enumerable: true, get: function () { return escpos_js_1.rasterZeilenBytes; } });
+Object.defineProperty(exports, "rasterZeilenBase64", { enumerable: true, get: function () { return escpos_js_1.rasterZeilenBase64; } });
+Object.defineProperty(exports, "escPosRasterBild", { enumerable: true, get: function () { return escpos_js_1.escPosRasterBild; } });
 Object.defineProperty(exports, "encodeEscPosText", { enumerable: true, get: function () { return escpos_js_1.encodeEscPosText; } });
 Object.defineProperty(exports, "qrCodeBytes", { enumerable: true, get: function () { return escpos_js_1.qrCodeBytes; } });
 Object.defineProperty(exports, "escPosMaxCharsPerLine", { enumerable: true, get: function () { return escpos_js_1.escPosMaxCharsPerLine; } });
@@ -30,6 +33,7 @@ Object.defineProperty(exports, "QR_AUSNAHME_PUNKTE", { enumerable: true, get: fu
 Object.defineProperty(exports, "QR_HOECHST_PUNKTE", { enumerable: true, get: function () { return qr_groesse_js_1.QR_HOECHST_PUNKTE; } });
 Object.defineProperty(exports, "QR_DRUCK_PUNKTE", { enumerable: true, get: function () { return qr_groesse_js_1.QR_DRUCK_PUNKTE; } });
 Object.defineProperty(exports, "qrModulAnzahl", { enumerable: true, get: function () { return qr_groesse_js_1.qrModulAnzahl; } });
+Object.defineProperty(exports, "qrPasstInVersion", { enumerable: true, get: function () { return qr_groesse_js_1.qrPasstInVersion; } });
 Object.defineProperty(exports, "qrGroesseBerechnen", { enumerable: true, get: function () { return qr_groesse_js_1.qrGroesseBerechnen; } });
 Object.defineProperty(exports, "qrGroesseFuer", { enumerable: true, get: function () { return qr_groesse_js_1.qrGroesseFuer; } });
 var printable_js_1 = require("./printable.js");

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

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

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

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

package/dist/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 };
+}