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

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

@@ -26,9 +26,9 @@
  *
  * Nicht enthalten (bewusst): Bilddekodierung (PNG/JPEG liest die Huelle),
  * Capability-Profile einzelner Druckermodelle, Kassenlade, 1D-Barcodes.
- * Fertige einfarbige Rasterbilder (Logo) gehen ueber [escPosRasterBild].
+ * Fertige einfarbige Rasterbilder (Logo) gehen ueber [escPosRasterImage].
  */
-import { type QrModulGroesse } from './qr-groesse.js';
+import { type QrModuleSize } from './qr-groesse.js';
 /** Papierbreite der Bonrolle. */
 export type PosPaperSize = 'mm58' | 'mm80';
 /** Ausrichtung einer Textzeile bzw. innerhalb einer Spalte. */
@@ -107,18 +107,18 @@ export interface EscPosQrOptions {
     /** Fehlerkorrektur; Vorgabe `M` wie auf allen Druckwegen (siehe `qrCodeBytes`). */
     correction?: QrCorrection;
     /** Deckel fuer die gerechnete Modulgroesse; wirkungslos neben `size`. */
-    groesse?: QrModulGroesse;
+    moduleSize?: QrModuleSize;
     /** Modell 1 des Symbols ausdruecklich waehlen — siehe `qrCodeBytes`. */
-    modell1?: boolean;
+    model1?: boolean;
 }
 export interface EscPosQrRasterOptions {
     align?: PosAlign;
     /** Feste Punkte je Modul; ohne Angabe gerechnet (mindestens 1). */
-    punkteJeModul?: number;
+    dotsPerModule?: number;
     /** Deckel fuer die gerechnete Groesse. */
-    groesse?: QrModulGroesse;
-    /** Ruhezone je Seite in Modulen; Vorgabe `QR_RUHEZONE_MODULE` (4). */
-    ruhezoneModule?: number;
+    moduleSize?: QrModuleSize;
+    /** Ruhezone je Seite in Modulen; Vorgabe `QR_QUIET_ZONE_MODULES` (4). */
+    quietZoneModules?: number;
 }
 /** Interner Stilzustand — immer vollstaendig, nie teilbefuellt. */
 interface AktuelleStile {
@@ -147,18 +147,18 @@ export interface EscPosDocument {
      * ist der QR die maschinenlesbare Signatur: das muss der Aufrufer erfahren,
      * ohne den Bytestrom zu durchsuchen.
      */
-    qrFehler: string | null;
+    qrError: string | null;
     /**
      * Der QR steht auf dem Papier, aber nicht so wie eingestellt — `null`,
      * solange nichts abgewichen ist. Zwei Faelle, beide mit Grund im Text: das
      * Symbol war fuer den nativen Befehl zu breit und ging als Bild hinaus, oder
      * es passte nur unter der Mindest-Modulgroesse.
      *
-     * Getrennt von `qrFehler`, weil die Handlung eine andere ist: dort heisst es
+     * Getrennt von `qrError`, weil die Handlung eine andere ist: dort heisst es
      * "Beleg ohne QR, nachdrucken oder elektronisch ausgeben", hier "gedruckt,
      * aber der eingestellte Weg taugt fuer dieses Geraet nicht".
      */
-    qrAusweich: string | null;
+    qrFallback: string | null;
     /** intern: bisher erzeugte Bytes */
     readonly bytes: number[];
     /** intern: global gesetzte Codepage (ueberlebt `escPosReset`) */
@@ -226,7 +226,7 @@ export declare function escPosSetGlobalFont(doc: EscPosDocument, font: PosFont |
  * geaendert haben. Fehlende Felder in [styles] gelten als Vorgabe: wer fett
  * weglaesst, schaltet fett also ab.
  *
- * `zeilenanfang` (Vorgabe `true`) sagt, ob dieser Aufruf am Anfang einer
+ * `atLineStart` (Vorgabe `true`) sagt, ob dieser Aufruf am Anfang einer
  * Druckzeile steht. Nur dort nimmt der Drucker `ESC a` (Ausrichtung)
  * ueberhaupt an; mitten in der Zeile verwirft er den Befehl wortlos. Der
  * Bytestrom bekommt ihn trotzdem -- die Bytefolge soll sich dadurch nicht
@@ -234,8 +234,8 @@ export declare function escPosSetGlobalFont(doc: EscPosDocument, font: PosFont |
  * Wert stellen: sonst haelt eine spaetere, echte Zeile die Ausrichtung
  * faelschlich schon fuer gesetzt und unterlaesst den Befehl.
  */
-export declare function escPosSetStyles(doc: EscPosDocument, styles?: PosStyles, optionen?: {
-    zeilenanfang?: boolean;
+export declare function escPosSetStyles(doc: EscPosDocument, styles?: PosStyles, options?: {
+    atLineStart?: boolean;
 }): void;
 /**
  * Wortweiser Umbruch von (kodierten) Text-Bytes auf hoechstens `max` Zeichen
@@ -244,7 +244,7 @@ export declare function escPosSetStyles(doc: EscPosDocument, styles?: PosStyles,
  * sonst kaeme die Zeile nie voran. Ein Bondrucker bricht sonst hart mitten
  * im Wort ("Kleinunter|nehmer", "0,7|9"); das soll nie aufs Papier.
  */
-export declare function escPosWortzeilen(textBytes: Uint8Array, max: number): Uint8Array[];
+export declare function escPosWrapLines(textBytes: Uint8Array, max: number): Uint8Array[];
 /**
  * Dieselbe Regel fuer Zeichenketten -- fuer Bildschirm-Vorschauen, die das
  * Papier nachstellen, und fuer das Zeichenraster. Zusaetzlich:
@@ -253,7 +253,7 @@ export declare function escPosWortzeilen(textBytes: Uint8Array, max: number): Ui
  * - ein ueberlanges Wort bricht nach einem Bindestrich, wenn es einen hat
  *   ("Bio-" / "Dinkelvollkornsemmel"), sonst hart.
  */
-export declare function wortzeilenText(text: string, max: number): string[];
+export declare function wrapText(text: string, max: number): string[];
 /**
  * Druckt Text und schliesst die Zeile ab. Nach dem Text folgt immer genau ein
  * Zeilenumbruch, `linesAfter` haengt weitere an.
@@ -284,7 +284,7 @@ export declare function escPosRow(doc: EscPosDocument, columns: readonly PosColu
  * 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
+ * (`qrModuleCount`), 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.
@@ -292,7 +292,7 @@ export declare function escPosRow(doc: EscPosDocument, columns: readonly PosColu
 export declare function qrCodeBytes(text: string, options?: {
     size?: QrSize;
     correction?: QrCorrection;
-    modell1?: boolean;
+    model1?: boolean;
 }): Uint8Array;
 /**
  * Setzt die Ausrichtung und haengt den nativen QR-Befehl an — mit
@@ -329,26 +329,26 @@ export declare function escPosQrRaster(doc: EscPosDocument, matrix: QrMatrix, op
  * dieses Papier bringt — dieselbe Rechnung, nur ohne Untergrenze 3: ein Bild
  * darf bis auf einen Punkt je Modul schrumpfen und passt darum immer.
  */
-export declare function qrRasterPunkte(paperSize: PosPaperSize, moduleAnzahl: number, options?: {
-    groesse?: QrModulGroesse;
-    ruhezoneModule?: number;
+export declare function qrRasterDots(paperSize: PosPaperSize, moduleCount: number, options?: {
+    moduleSize?: QrModuleSize;
+    quietZoneModules?: number;
 }): number;
 /**
  * Einfarbiges Rasterbild in Druckpunkten, zeilenweise: `punkte[y * breite + x]`,
- * 1 = schwarz. Entsteht fuer das Firmenlogo in `logoRaster` (receipt/bild.ts).
+ * 1 = schwarz. Entsteht fuer das Firmenlogo in `rasterizeLogo` (receipt/bild.ts).
  */
-export interface RasterBild {
-    readonly breite: number;
-    readonly hoehe: number;
-    readonly punkte: Uint8Array;
+export interface RasterImage {
+    readonly width: number;
+    readonly height: number;
+    readonly dots: Uint8Array;
 }
 /** Die Rasterzeilen als Bytes: MSB zuerst, jede Zeile auf volle Bytes aufgefuellt. */
-export declare function rasterZeilenBytes(bild: RasterBild): Uint8Array;
+export declare function rasterRowsBytes(image: RasterImage): Uint8Array;
 /**
  * Die Rasterzeilen als Base64 -- ohne Buffer, laeuft im Browser und in Node.
  * Eine Stelle fuer ePOS-`<image>` und den Druckjob an den Server.
  */
-export declare function rasterZeilenBase64(bild: RasterBild): string;
+export declare function rasterRowsBase64(image: RasterImage): string;
 /**
  * Ein Rasterbild (`GS v 0`) -- das Firmenlogo am Bon.
  *
@@ -356,7 +356,7 @@ export declare function rasterZeilenBase64(bild: RasterBild): string;
  * 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.
  */
-export declare function escPosRasterBild(doc: EscPosDocument, bild: RasterBild, options?: {
+export declare function escPosRasterImage(doc: EscPosDocument, image: RasterImage, options?: {
     align?: PosAlign;
 }): void;
 export {};

package/dist/esm/printing/escpos.js

@@ -26,9 +26,9 @@
  *
  * Nicht enthalten (bewusst): Bilddekodierung (PNG/JPEG liest die Huelle),
  * Capability-Profile einzelner Druckermodelle, Kassenlade, 1D-Barcodes.
- * Fertige einfarbige Rasterbilder (Logo) gehen ueber [escPosRasterBild].
+ * Fertige einfarbige Rasterbilder (Logo) gehen ueber [escPosRasterImage].
  */
-import { QR_DRUCK_PUNKTE, QR_MINDEST_PUNKTE, QR_MODUL_DECKEL, QR_RUHEZONE_MODULE, qrGroesseFuer, } from './qr-groesse.js';
+import { QR_PRINT_WIDTH_DOTS, QR_MIN_MODULE_DOTS, QR_MODULE_SIZE_CAP, QR_QUIET_ZONE_MODULES, qrSizingFor, } from './qr-groesse.js';
 // -------------------------------------------------------------- Befehlsbytes
 // Wortwoertlich aus commands.dart. Die Zahlen sind ASCII-Codes der dortigen
 // Zeichenketten: cCutFull = '$gs' + 'V0' ist GS 0x56 0x30 — die Ziffer '0',
@@ -225,8 +225,8 @@ export function createEscPosDocument(options = {}) {
         globalFont: null,
         maxCharsPerLine: null,
         styles: vollstaendigeStile(),
-        qrFehler: null,
-        qrAusweich: null,
+        qrError: null,
+        qrFallback: null,
     };
 }
 /** Die bisher erzeugten Bytes als Kopie. */
@@ -244,8 +244,8 @@ export function escPosReset(doc) {
     doc.styles = vollstaendigeStile();
     // Wie `PrintPaper.reset()` im Flutter-Zwilling: ein neu begonnener Beleg
     // erbt die QR-Meldungen des vorigen nicht.
-    doc.qrFehler = null;
-    doc.qrAusweich = null;
+    doc.qrError = null;
+    doc.qrFallback = null;
     escPosSetGlobalCodeTable(doc, doc.globalCodeTable);
     escPosSetGlobalFont(doc, doc.globalFont);
 }
@@ -308,7 +308,7 @@ export function escPosSetGlobalFont(doc, font, options = {}) {
  * geaendert haben. Fehlende Felder in [styles] gelten als Vorgabe: wer fett
  * weglaesst, schaltet fett also ab.
  *
- * `zeilenanfang` (Vorgabe `true`) sagt, ob dieser Aufruf am Anfang einer
+ * `atLineStart` (Vorgabe `true`) sagt, ob dieser Aufruf am Anfang einer
  * Druckzeile steht. Nur dort nimmt der Drucker `ESC a` (Ausrichtung)
  * ueberhaupt an; mitten in der Zeile verwirft er den Befehl wortlos. Der
  * Bytestrom bekommt ihn trotzdem -- die Bytefolge soll sich dadurch nicht
@@ -316,10 +316,10 @@ export function escPosSetGlobalFont(doc, font, options = {}) {
  * Wert stellen: sonst haelt eine spaetere, echte Zeile die Ausrichtung
  * faelschlich schon fuer gesetzt und unterlaesst den Befehl.
  */
-export function escPosSetStyles(doc, styles = {}, optionen = {}) {
+export function escPosSetStyles(doc, styles = {}, options = {}) {
     const neu = vollstaendigeStile(styles);
     const alt = doc.styles;
-    const zeilenanfang = optionen.zeilenanfang ?? true;
+    const zeilenanfang = options.atLineStart ?? true;
     if (neu.align !== alt.align) {
         anhaengen(doc, neu.align === 'left' ? C_ALIGN_LEFT : neu.align === 'center' ? C_ALIGN_CENTER : C_ALIGN_RIGHT);
         if (zeilenanfang)
@@ -370,7 +370,7 @@ export function escPosSetStyles(doc, styles = {}, optionen = {}) {
  * sonst kaeme die Zeile nie voran. Ein Bondrucker bricht sonst hart mitten
  * im Wort ("Kleinunter|nehmer", "0,7|9"); das soll nie aufs Papier.
  */
-export function escPosWortzeilen(textBytes, max) {
+export function escPosWrapLines(textBytes, max) {
     const grenze = Math.max(1, Math.floor(max));
     const out = [];
     let rest = textBytes;
@@ -434,7 +434,7 @@ function verketten(teile) {
  * - ein ueberlanges Wort bricht nach einem Bindestrich, wenn es einen hat
  *   ("Bio-" / "Dinkelvollkornsemmel"), sonst hart.
  */
-export function wortzeilenText(text, max) {
+export function wrapText(text, max) {
     const grenze = Math.max(1, Math.floor(max));
     const out = [];
     let rest = text;
@@ -486,7 +486,7 @@ function textIntern(doc, textBytes, optionen = {}) {
     const stileFuerDrucker = colInd === 0 && !volleZeile ? { ...optionen.styles, align: 'left' } : optionen.styles;
     // Ausrichtung vor Position -- `ESC a` gilt nur am Zeilenanfang, nach `ESC $`
     // verwirft der Drucker ihn. Zwilling von `_text` in generator.dart.
-    escPosSetStyles(doc, stileFuerDrucker, { zeilenanfang: colInd === 0 });
+    escPosSetStyles(doc, stileFuerDrucker, { atLineStart: colInd === 0 });
     // Eine volle Zeile beginnt am linken Rand; ein Positionsbefehl dafuer waere
     // nicht nur ueberfluessig, er entwertet die Ausrichtung.
     if (!volleZeile) {
@@ -522,7 +522,7 @@ export function escPosText(doc, text, options = {}) {
     // selbst wuerde hart mitten im Wort umbrechen.
     const stile = vollstaendigeStile(options.styles);
     const zeichenJeZeile = Math.max(1, Math.floor(zeichenProZeile(doc, stile) / (stile.width === 2 ? 2 : 1)));
-    const zeilen = escPosWortzeilen(encodeEscPosText(text, doc.globalCodeTable ?? 'CP1252'), zeichenJeZeile);
+    const zeilen = escPosWrapLines(encodeEscPosText(text, doc.globalCodeTable ?? 'CP1252'), zeichenJeZeile);
     zeilen.forEach((z, i) => {
         textIntern(doc, z, { styles: options.styles });
         if (i < zeilen.length - 1)
@@ -613,7 +613,7 @@ export function escPosRow(doc, columns) {
             if (zuDrucken.length > maxZeichen) {
                 // Wortweise: erste Zeile bis zum letzten Leerzeichen innerhalb der
                 // Spalte, der Rest (ohne fuehrende Leerzeichen) in die Folgezeile.
-                const [erste, ...weitere] = escPosWortzeilen(zuDrucken, maxZeichen);
+                const [erste, ...weitere] = escPosWrapLines(zuDrucken, maxZeichen);
                 const rest = weitere.length ? verketten(weitere) : new Uint8Array(0);
                 folge.textEncoded = rest;
                 zuDrucken = erste;
@@ -646,7 +646,7 @@ export function escPosRow(doc, columns) {
  * 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
+ * (`qrModuleCount`), 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.
@@ -674,7 +674,7 @@ export function qrCodeBytes(text, options = {}) {
     // Befehl erkannt hat. Der Befehl geht deshalb nur hinaus, wenn er
     // ausdruecklich verlangt ist; ein aufgedraengtes "Modell 2 fuer alle" waere
     // eine stille Umstellung an jedem Bestandsgeraet.
-    if (options.modell1 === true) {
+    if (options.model1 === true) {
         bytes.push(...C_QR_HEADER, 0x04, 0x00, 0x31, 0x41, 0x31, 0x00);
     }
     // Funktion 167: Modulgroesse
@@ -714,31 +714,31 @@ export function escPosQrCode(doc, text, options = {}) {
     const qrOptionen = {};
     if (options.correction !== undefined)
         qrOptionen.correction = options.correction;
-    if (options.modell1 !== undefined)
-        qrOptionen.modell1 = options.modell1;
+    if (options.model1 !== undefined)
+        qrOptionen.model1 = options.model1;
     let drucken = true;
     if (options.size !== undefined) {
         qrOptionen.size = options.size;
     }
     else if (text !== '') {
-        const mass = qrGroesseFuer({
-            nutzlast: text,
-            papierbreitePunkte: QR_DRUCK_PUNKTE[doc.paperSize],
-            groesse: options.groesse ?? 'auto',
+        const mass = qrSizingFor({
+            payload: text,
+            paperWidthDots: QR_PRINT_WIDTH_DOTS[doc.paperSize],
+            moduleSize: options.moduleSize ?? 'auto',
         });
-        if (!mass.passt) {
-            doc.qrFehler =
-                `QR mit ${mass.module} Modulen ist fuer ${PAPIER_MM[doc.paperSize]} mm ` +
-                    `(${QR_DRUCK_PUNKTE[doc.paperSize]} Punkte) zu breit`;
+        if (!mass.fits) {
+            doc.qrError =
+                `QR mit ${mass.modules} Modulen ist fuer ${PAPIER_MM[doc.paperSize]} mm ` +
+                    `(${QR_PRINT_WIDTH_DOTS[doc.paperSize]} Punkte) zu breit`;
             drucken = false;
         }
         else {
-            if (mass.unterMindestmass) {
-                doc.qrAusweich =
-                    `QR mit ${mass.module} Modulen passt nur mit ${String(mass.punkte)} Punkten ` +
-                        `je Modul — unter dem Mindestmass von ${QR_MINDEST_PUNKTE}`;
+            if (mass.belowMinimum) {
+                doc.qrFallback =
+                    `QR mit ${mass.modules} Modulen passt nur mit ${String(mass.moduleDots)} Punkten ` +
+                        `je Modul — unter dem Mindestmass von ${QR_MIN_MODULE_DOTS}`;
             }
-            qrOptionen.size = mass.punkte;
+            qrOptionen.size = mass.moduleDots;
         }
     }
     if (drucken)
@@ -763,15 +763,15 @@ export function escPosQrRaster(doc, matrix, options = {}) {
         if (zeile.length !== module)
             throw new Error('QR-Raster ist nicht quadratisch');
     }
-    const ruhezone = options.ruhezoneModule ?? QR_RUHEZONE_MODULE;
+    const ruhezone = options.quietZoneModules ?? QR_QUIET_ZONE_MODULES;
     if (!istGanzzahl(ruhezone) || ruhezone < 0) {
         throw new Error('ruhezoneModule muss eine Ganzzahl >= 0 sein');
     }
     const gesamtModule = module + 2 * ruhezone;
-    let punkte = options.punkteJeModul;
+    let punkte = options.dotsPerModule;
     if (punkte === undefined) {
-        const deckel = QR_MODUL_DECKEL[options.groesse ?? 'auto'];
-        punkte = Math.max(1, Math.min(deckel, Math.floor(QR_DRUCK_PUNKTE[doc.paperSize] / gesamtModule)));
+        const deckel = QR_MODULE_SIZE_CAP[options.moduleSize ?? 'auto'];
+        punkte = Math.max(1, Math.min(deckel, Math.floor(QR_PRINT_WIDTH_DOTS[doc.paperSize] / gesamtModule)));
     }
     if (!istGanzzahl(punkte) || punkte < 1) {
         throw new Error('punkteJeModul muss eine Ganzzahl >= 1 sein');
@@ -794,7 +794,7 @@ export function escPosQrRaster(doc, matrix, options = {}) {
             bildpunkte[y * breite + x] = 1;
         }
     }
-    const daten = rasterZeilenBytes({ breite, hoehe: breite, punkte: bildpunkte });
+    const daten = rasterRowsBytes({ width: breite, height: breite, dots: 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, rasterBildKopf(breite, breite));
@@ -806,23 +806,23 @@ export function escPosQrRaster(doc, matrix, options = {}) {
  * dieses Papier bringt — dieselbe Rechnung, nur ohne Untergrenze 3: ein Bild
  * darf bis auf einen Punkt je Modul schrumpfen und passt darum immer.
  */
-export function qrRasterPunkte(paperSize, moduleAnzahl, options = {}) {
-    const ruhezone = options.ruhezoneModule ?? QR_RUHEZONE_MODULE;
-    const deckel = QR_MODUL_DECKEL[options.groesse ?? 'auto'];
-    return Math.max(1, Math.min(deckel, Math.floor(QR_DRUCK_PUNKTE[paperSize] / (moduleAnzahl + 2 * ruhezone))));
+export function qrRasterDots(paperSize, moduleCount, options = {}) {
+    const ruhezone = options.quietZoneModules ?? QR_QUIET_ZONE_MODULES;
+    const deckel = QR_MODULE_SIZE_CAP[options.moduleSize ?? 'auto'];
+    return Math.max(1, Math.min(deckel, Math.floor(QR_PRINT_WIDTH_DOTS[paperSize] / (moduleCount + 2 * ruhezone))));
 }
 /** Die Rasterzeilen als Bytes: MSB zuerst, jede Zeile auf volle Bytes aufgefuellt. */
-export function rasterZeilenBytes(bild) {
-    if (!istGanzzahl(bild.breite) || bild.breite < 1 || !istGanzzahl(bild.hoehe) || bild.hoehe < 1) {
+export function rasterRowsBytes(image) {
+    if (!istGanzzahl(image.width) || image.width < 1 || !istGanzzahl(image.height) || image.height < 1) {
         throw new Error('Rasterbild ohne gueltiges Mass');
     }
-    if (bild.punkte.length !== bild.breite * bild.hoehe)
+    if (image.dots.length !== image.width * image.height)
         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)
+    const byteJeZeile = Math.ceil(image.width / 8);
+    const daten = new Uint8Array(byteJeZeile * image.height);
+    for (let y = 0; y < image.height; y++) {
+        for (let x = 0; x < image.width; x++) {
+            if (image.dots[y * image.width + x] !== 1)
                 continue;
             const i = y * byteJeZeile + (x >> 3);
             daten[i] = daten[i] | (0x80 >> (x & 7));
@@ -834,8 +834,8 @@ export function rasterZeilenBytes(bild) {
  * Die Rasterzeilen als Base64 -- ohne Buffer, laeuft im Browser und in Node.
  * Eine Stelle fuer ePOS-`<image>` und den Druckjob an den Server.
  */
-export function rasterZeilenBase64(bild) {
-    const bytes = rasterZeilenBytes(bild);
+export function rasterRowsBase64(image) {
+    const bytes = rasterRowsBytes(image);
     let binaer = '';
     for (let i = 0; i < bytes.length; i += 0x8000) {
         binaer += String.fromCharCode(...bytes.subarray(i, i + 0x8000));
@@ -844,7 +844,7 @@ export function rasterZeilenBase64(bild) {
 }
 /**
  * Der `GS v 0`-Kopf (Byte-Breite, Zeilenhoehe) -- die Rasterzeilen selbst
- * haengt der Aufrufer an. Gemeinsame Rahmung fuer das Logo (`escPosRasterBild`)
+ * haengt der Aufrufer an. Gemeinsame Rahmung fuer das Logo (`escPosRasterImage`)
  * und den QR-Bildweg (`escPosQrRaster`): beide drucken dasselbe Bildkommando,
  * nur mit unterschiedlichem Nachlauf (Zeilenvorschub ja/nein).
  */
@@ -859,17 +859,17 @@ function rasterBildKopf(breite, hoehe) {
  * 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.
  */
-export function escPosRasterBild(doc, bild, options = {}) {
+export function escPosRasterImage(doc, image, 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_DRUCK_PUNKTE[doc.paperSize])
+    if (image.width > QR_PRINT_WIDTH_DOTS[doc.paperSize])
         throw new Error('Rasterbild breiter als der Druckkopf');
-    if (bild.hoehe > 0xffff)
+    if (image.height > 0xffff)
         throw new Error('Rasterbild hoeher als 65535 Punkte');
-    const daten = rasterZeilenBytes(bild);
+    const daten = rasterRowsBytes(image);
     escPosSetStyles(doc, { align: options.align ?? 'center' });
-    anhaengen(doc, rasterBildKopf(bild.breite, bild.hoehe));
+    anhaengen(doc, rasterBildKopf(image.width, image.height));
     anhaengen(doc, daten);
 }

package/dist/esm/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, 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 { 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, qrRasterDots, type RasterImage, rasterRowsBytes, rasterRowsBase64, escPosRasterImage, encodeEscPosText, qrCodeBytes, escPosMaxCharsPerLine, escPosWrapLines, wrapText, } from './escpos.js';
+export { type QrModuleSize, type QrSizing, QR_MODULE_SIZE_CAP, QR_QUIET_ZONE_MODULES, QR_MIN_MODULE_DOTS, QR_EXCEPTION_MODULE_DOTS, QR_MAX_MODULE_DOTS, QR_PRINT_WIDTH_DOTS, qrModuleCount, qrFitsInVersion, computeQrSizing, qrSizingFor, } 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/esm/printing/index.js

@@ -1,4 +1,4 @@
-export { createEscPosDocument, escPosBytes, escPosReset, escPosSetGlobalCodeTable, escPosSetGlobalFont, escPosSetStyles, escPosText, escPosEmptyLines, escPosFeed, escPosCut, escPosHr, escPosRow, escPosQrCode, escPosQrRaster, qrRasterPunkte, rasterZeilenBytes, rasterZeilenBase64, escPosRasterBild, encodeEscPosText, qrCodeBytes, escPosMaxCharsPerLine, escPosWortzeilen, wortzeilenText, } from './escpos.js';
-export { 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 { createEscPosDocument, escPosBytes, escPosReset, escPosSetGlobalCodeTable, escPosSetGlobalFont, escPosSetStyles, escPosText, escPosEmptyLines, escPosFeed, escPosCut, escPosHr, escPosRow, escPosQrCode, escPosQrRaster, qrRasterDots, rasterRowsBytes, rasterRowsBase64, escPosRasterImage, encodeEscPosText, qrCodeBytes, escPosMaxCharsPerLine, escPosWrapLines, wrapText, } from './escpos.js';
+export { QR_MODULE_SIZE_CAP, QR_QUIET_ZONE_MODULES, QR_MIN_MODULE_DOTS, QR_EXCEPTION_MODULE_DOTS, QR_MAX_MODULE_DOTS, QR_PRINT_WIDTH_DOTS, qrModuleCount, qrFitsInVersion, computeQrSizing, qrSizingFor, } from './qr-groesse.js';
 export { escPosPrintableText } from './printable.js';
 export { USB_VENDOR_EPSON, USB_CLASS_PRINTER, UsbTimeoutError, usbDeviceKey, usbFindPrinterEndpoint, usbWriteAll, usbConnectPrinter, usbPrint, usbDisconnect, } from './webusb.js';

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

@@ -23,46 +23,46 @@ import type { PosPaperSize, QrSize } from './escpos.js';
  * 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.
+ * liest sich besser. `small` (4) druckt den QR so gross wie frueher `auto`;
+ * `medium` (6) und `large` (8) waehlt ein Mensch.
  */
-export type QrModulGroesse = 'auto' | 'klein' | 'mittel' | 'gross';
+export type QrModuleSize = 'auto' | 'small' | 'medium' | 'large';
 /** Groesste Modulgroesse in Druckpunkten, die der jeweilige Deckel zulaesst. */
-export declare const QR_MODUL_DECKEL: Readonly<Record<QrModulGroesse, number>>;
+export declare const QR_MODULE_SIZE_CAP: Readonly<Record<QrModuleSize, number>>;
 /**
  * Ergebnis der Modulgroessen-Rechnung.
  *
- * Traegt bewusst mehr als die Zahl: ob ueberhaupt etwas passt (`passt`), ob
- * nur unter der Mindestgroesse (`unterMindestmass`) und wie breit das Symbol
- * wird (`breitePunkte`). Eine blosse Zahl haette die Ausnahme verschwiegen.
+ * Traegt bewusst mehr als die Zahl: ob ueberhaupt etwas passt (`fits`), ob
+ * nur unter der Mindestgroesse (`belowMinimum`) und wie breit das Symbol
+ * wird (`widthDots`). Eine blosse Zahl haette die Ausnahme verschwiegen.
  */
-export interface QrGroesse {
+export interface QrSizing {
     /**
      * Modulgroesse in Druckpunkten, `null` wenn das Symbol auch mit der
      * Ausnahmegroesse nicht aufs Papier passt.
      */
-    readonly punkte: QrSize | null;
+    readonly moduleDots: QrSize | null;
     /** Modulanzahl des Symbols (ohne Ruhezone). */
-    readonly module: number;
+    readonly modules: number;
     /** Gesamtbreite inklusive Ruhezone in Druckpunkten; 0, wenn nichts passt. */
-    readonly breitePunkte: number;
+    readonly widthDots: number;
     /**
-     * Gedruckt wird unter `QR_MINDEST_PUNKTE`. Erlaubt, aber eine Ausnahme, von
+     * Gedruckt wird unter `QR_MIN_MODULE_DOTS`. Erlaubt, aber eine Ausnahme, von
      * der der Aufrufer erfahren muss — billige Thermodrucker und Handykameras
      * tun sich damit schwer, besonders auf gewelltem Papier.
      */
-    readonly unterMindestmass: boolean;
+    readonly belowMinimum: boolean;
     /** Kurz fuer `punkte !== null`. */
-    readonly passt: boolean;
+    readonly fits: boolean;
 }
 /** Ruhezone je Seite, in Modulen (QR-Norm). */
-export declare const QR_RUHEZONE_MODULE = 4;
+export declare const QR_QUIET_ZONE_MODULES = 4;
 /** Untergrenze: 4 Punkte sind bei 203 dpi rund 0,5 mm je Modul. */
-export declare const QR_MINDEST_PUNKTE = 4;
-/** Ausnahme, wenn `QR_MINDEST_PUNKTE` nicht passt — gemeldet, nicht still. */
-export declare const QR_AUSNAHME_PUNKTE = 3;
+export declare const QR_MIN_MODULE_DOTS = 4;
+/** Ausnahme, wenn `QR_MIN_MODULE_DOTS` nicht passt – gemeldet, nicht still. */
+export declare const QR_EXCEPTION_MODULE_DOTS = 3;
 /** Obergrenze des Druckbefehls in diesem Stack (`GS ( k` Funktion 167: 1..8). */
-export declare const QR_HOECHST_PUNKTE = 8;
+export declare const QR_MAX_MODULE_DOTS = 8;
 /**
  * Druckbreite des Kopfes in Punkten (203 dpi): 58 mm = 384, 80 mm = 576 —
  * Zwilling von `KeckPaperSize.druckPunkte`.
@@ -73,9 +73,9 @@ export declare const QR_HOECHST_PUNKTE = 8;
  * die echte Kopfbreite — ein QR, der auch nur einen Punkt zu breit ist, wird
  * von den meisten Geraeten gar nicht gedruckt.
  */
-export declare const QR_DRUCK_PUNKTE: Readonly<Record<PosPaperSize, number>>;
+export declare const QR_PRINT_WIDTH_DOTS: Readonly<Record<PosPaperSize, number>>;
 /**
- * Modulanzahl, die `nutzlast` bei Fehlerkorrektur **M** braucht.
+ * Modulanzahl, die `payload` bei Fehlerkorrektur **M** braucht.
  *
  * Alle Druckwege setzen den QR mit Fehlerkorrektur **M** (nativer
  * ESC/POS-Befehl, ePOS `level_m`; das Raster fuer den Bildweg rechnet der
@@ -90,38 +90,38 @@ export declare const QR_DRUCK_PUNKTE: Readonly<Record<PosPaperSize, number>>;
  * langem Inhalt. Ein still zurueckgegebenes "passt nicht" haette den
  * Datenfehler als Papierfehler getarnt.
  */
-export declare function qrModulAnzahl(nutzlast: string): number;
+export declare function qrModuleCount(payload: string): number;
 /**
- * Ob `nutzlast` in irgendeine QR-Version 1..40 bei Fehlerkorrektur M passt --
- * dieselbe Tabelle wie `qrModulAnzahl`, aber ohne zu werfen.
+ * Ob `payload` in irgendeine QR-Version 1..40 bei Fehlerkorrektur M passt --
+ * dieselbe Tabelle wie `qrModuleCount`, 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;
+export declare function qrFitsInVersion(payload: string): boolean;
 /**
- * Groesste Modulgroesse, mit der `moduleAnzahl` Module **samt Ruhezone** in
- * `papierbreitePunkte` passen, gedeckelt durch `groesse`.
+ * Groesste Modulgroesse, mit der `moduleCount` Module **samt Ruhezone** in
+ * `paperWidthDots` passen, gedeckelt durch `moduleSize`.
  *
  * Wirft bei sinnlosen Eingaben: eine Papierbreite von 0 oder ein Symbol ohne
  * Module ist ein Programmierfehler, und ein still zurueckgegebenes "passt
  * nicht" haette ihn als Druckerproblem getarnt.
  */
-export declare function qrGroesseBerechnen(options: {
-    papierbreitePunkte: number;
-    moduleAnzahl: number;
-    groesse?: QrModulGroesse;
-}): QrGroesse;
+export declare function computeQrSizing(options: {
+    paperWidthDots: number;
+    moduleCount: number;
+    moduleSize?: QrModuleSize;
+}): QrSizing;
 /**
- * Wie `qrGroesseBerechnen`, nur mit der Modulanzahl aus `nutzlast`.
+ * Wie `computeQrSizing`, nur mit der Modulanzahl aus `payload`.
  *
  * Eine leere Nutzlast ergibt kein Symbol — sie "passt nicht", statt zu
  * werfen: der Aufrufer behandelt den Fall ohnehin schon (leerer QR am Beleg
  * ist ein Datenfehler, kein Papierfehler).
  */
-export declare function qrGroesseFuer(options: {
-    nutzlast: string;
-    papierbreitePunkte: number;
-    groesse?: QrModulGroesse;
-}): QrGroesse;
+export declare function qrSizingFor(options: {
+    payload: string;
+    paperWidthDots: number;
+    moduleSize?: QrModuleSize;
+}): QrSizing;