@kreiseck/kasseneck-api 1.0.0 → 1.1.1

package/dist/esm/printing/printable.js

@@ -15,6 +15,7 @@
  * ersatzlos weg, alles Uebrige auf `?`. Ein Artikelname aus einer
  * ERP-Uebernahme mit Gedankenstrich soll den Beleg nicht verhindern.
  */
+import { codeTableById, ersatzBuchstaben } from './code-tables.js';
 /** Ersetzungen aus print_paper.dart, Schluessel sind Unicode-Codepunkte. */
 const ERSETZUNGEN = new Map([
     [0x2013, '-'], // – Halbgeviertstrich
@@ -63,12 +64,34 @@ function istEmojiOderNullbreite(codepunkt) {
  * Vor `escPosText`/`escPosRow` anwenden, wenn der Text aus fremder Hand kommt
  * (Artikelstamm, ERP-Uebernahme, Kundenname). `•` wird hier zu `*`, und der
  * Erzeuger sagt dasselbe — auch wer diese Funktion weglaesst, bekommt also
- * dasselbe Zeichen (siehe ZEICHEN_ERSATZ in escpos.ts).
+ * dasselbe Zeichen (siehe ZEICHEN_ERSATZ in code-tables.ts).
+ *
+ * Mit `codeTable` wird der Text fuer genau diese Tabelle fertig gemacht:
+ * - eine Tabelle des Katalogs (`CodeTableId`): `€` bleibt stehen, wenn die
+ *   Tabelle es hat (der Drucker bekommt das echte Byte), sonst `EUR`; jedes
+ *   der zehn Zeichen, das der Tabelle fehlt (`§` auf pc437, alle Umlaute auf
+ *   `replacement` ...), wird schon hier zu seinen Ersatzbuchstaben. Danach
+ *   ist jedes Zeichen genau ein Byte, und Spalten, die am Text gerechnet
+ *   werden, stimmen auch am Papier.
+ * - `CP437` (alter Name): wie `pc437`, also `§` -> `Par.`.
+ * - ohne Angabe, `null` oder `CP1252`: genau wie bisher (Bons ohne gewaehlte
+ *   Tabelle bleiben byte-gleich).
  */
-export function escPosPrintableText(text) {
+export function escPosPrintableText(text, codeTable) {
+    const tabelle = tabelleFuerErsatz(codeTable);
+    const fehlend = tabelle === null ? [] : codeTableById(tabelle).missing;
+    const echtesEuro = tabelle !== null && !fehlend.includes('€');
     let ergebnis = '';
     for (const zeichen of text) {
         const codepunkt = zeichen.codePointAt(0);
+        if (fehlend.includes(zeichen)) {
+            ergebnis += ersatzBuchstaben(zeichen);
+            continue;
+        }
+        if (codepunkt === 0x20ac && echtesEuro) {
+            ergebnis += zeichen;
+            continue;
+        }
         const ersatz = ERSETZUNGEN.get(codepunkt);
         if (ersatz !== undefined) {
             ergebnis += ersatz;
@@ -85,3 +108,14 @@ export function escPosPrintableText(text) {
     }
     return ergebnis;
 }
+/**
+ * Tabelle, deren fehlende Zeichen schon am Text ersetzt werden. `null` heisst
+ * alter Weg ohne Aenderung (keine Wahl, `null`, `CP1252`).
+ */
+function tabelleFuerErsatz(codeTable) {
+    if (codeTable === undefined || codeTable === null || codeTable === 'CP1252')
+        return null;
+    if (codeTable === 'CP437')
+        return 'pc437';
+    return codeTable;
+}

package/dist/esm/react/index.js

@@ -90,6 +90,13 @@ export function ReceiptSheetLines({ sheet: blatt, logoUrl, renderQr, qrHidden: q
     return (_jsx("div", { className: klasse, "data-zeichen": z, style: blattStil, children: blatt.blocks.map((b, i) => {
             switch (b.kind) {
                 case 'line':
+                    if (b.doubleSizeLead !== undefined && b.doubleSizeLead > 0) {
+                        // Wie am Papier (`GS !` doppelt): die Nummernzelle in doppelter
+                        // Schrift, die Zeile zwei Zeilen hoch, der Rest auf der Grundlinie.
+                        // `ch` im Span misst die doppelte Schrift, darum die halbe Zahl.
+                        const n = b.doubleSizeLead;
+                        return (_jsxs("div", { className: "keck-blatt-zeile keck-blatt-zeile--gross", style: { display: 'flex', alignItems: 'flex-end', whiteSpace: 'pre', height: '4ch', overflow: 'hidden', fontWeight: b.bold ? 'bold' : 'normal' }, children: [_jsx("span", { style: { fontSize: '2em', width: `${n / 2}ch`, lineHeight: '2ch', fontWeight: 'bold', textAlign: 'center', flex: 'none' }, children: b.text.slice(0, n).trim() }), _jsx("span", { style: { lineHeight: '2ch' }, children: b.text.slice(n) })] }, i));
+                    }
                     return (_jsx("div", { className: "keck-blatt-zeile", style: { whiteSpace: 'pre', height: '2ch', lineHeight: '2ch', overflow: 'hidden', fontWeight: b.bold ? 'bold' : 'normal' }, children: b.text }, i));
                 case 'logo':
                     return (_jsx("div", { className: "keck-blatt-logo", style: { height: `${b.heightLines * 2}ch`, display: 'flex', justifyContent: 'center' }, children: logoUrl === undefined ? null : (_jsx("img", { src: logoUrl, alt: "", "aria-hidden": "true", style: { width: `${b.widthFraction * z}ch`, height: `${b.heightLines * 2}ch`, objectFit: 'contain' } })) }, i));

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

@@ -40,6 +40,15 @@ export type SheetBlock = {
     readonly text: string;
     readonly bold: boolean;
     readonly blank: boolean;
+    /**
+     * Die ersten n Spalten sind EINE Zelle, deren Inhalt (ohne Leerraum)
+     * doppelt breit und doppelt hoch steht -- die Zeile ist dann zwei
+     * Zeilen hoch. Nur das Testblatt des Zeichensatzes setzt das (Nummern
+     * links); fehlt es, ist alles einfach gross. Ein Zeichner, der das Feld
+     * nicht kennt, zeigt die Zeile in einfacher Groesse, die Spalten
+     * bleiben dieselben.
+     */
+    readonly doubleSizeLead?: number;
 } | {
     readonly kind: 'logo';
     readonly widthFraction: number;

package/dist/esm/receipt/code-table-reference-data.d.ts

@@ -0,0 +1,6 @@
+/** Die Vorlage-Zeile als Rasterbild: 384 x 24 Punkte, MSB zuerst, je Zeile auf volle Bytes aufgefuellt; base64. */
+export declare const CODE_TABLE_REFERENCE_RASTER: {
+    readonly width: number;
+    readonly height: number;
+    readonly bits: string;
+};

package/dist/esm/receipt/code-table-reference-data.js

@@ -0,0 +1,8 @@
+// Erzeugt von scripts/zeichensatz-vorlage.py -- nicht von Hand aendern.
+// Schrift: Menlo Regular 20 px (sha256 dc256e0b39c2a6fec947129d421fef41b8b429f58f9b6e5d1b148c87f775c1f6), Schwelle 160.
+/** Die Vorlage-Zeile als Rasterbild: 384 x 24 Punkte, MSB zuerst, je Zeile auf volle Bytes aufgefuellt; base64. */
+export const CODE_TABLE_REFERENCE_RASTER = {
+    width: 384,
+    height: 24,
+    bits: "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGYAAGYAAGYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGYAAGYAAGYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGYAAGYAAGYAABgAADwAAIEAAH4AAB8AAD4AADwAAAAAAAAAAAAAAAAAAAAAAAAAAGYAAGYAAGYAADwAAH4AAcOAAOcAAD8AAH4AAH4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADwAAMMAAcOAAMMAAHAAAGAAAEIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADwAAMMAAcOAAMMAAOAAAGAAAEIAAAAAAAAAAAAAAAAAAAAAAAAAAP4AAH4AAMMAAGYAAcOAAcOAAMwAAMAAAHAAAGYAAAAAAAAAAAAAAAAAAAAAAAAAAOcAAOcAAMMAAGYAAYGAAcOAANgAAfwAAHgAADwAAAAAAAAAAAAAAAAAAAAAAAAAAAMAAMMAAMMAAGYAAYGAAcOAANgAAfwAAM4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAAcOAAMMAAGcAAYGAAcOAANwAAMAAAMcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAH8AAYGAAMMAAMMAAYGAAcOAAM4AAfgAAMMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAYGAAMMAAP8AAYGAAcOAAMcAA/gAAOMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcMAAYGAAMMAAP8AAcGAAcOAAMGAAMAAAHsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYMAAcOAAMMAAcOAAcOAAcOAAMGAAOAAAB4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYMAAMMAAMMAAYGAAMMAAMMAAMGAAGAAAAYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAO8AAOcAAP8AAYGAAP8AAP8AAPOAAH8AAAcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAH4AAH8AA4HAAH4AAH4AAP8AAD8AAAcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAH4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",
+};

package/dist/esm/receipt/code-table-test-sheet.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Das Testblatt fuer den Zeichensatz: welche Code-Tabelle druckt auf diesem
+ * Drucker die Umlaute richtig?
+ *
+ * Oben steht die Vorlage-Zeile als Rasterbild -- ein Bild druckt jeder
+ * Drucker gleich, egal welche Tabelle er gerade hat. Darunter je Tabelle des
+ * Katalogs eine Zeile mit ihrer Nummer (gross), umgeschaltet mit `ESC t n`
+ * und mit den Bytes dieser Tabelle. Richtig ist die Zeile ohne falsches
+ * Zeichen; eine Luecke (Zeichen fehlt der Tabelle) ist in Ordnung, bei
+ * mehreren die mit den wenigsten Luecken, sonst Zeile 6 (Ersatzbuchstaben).
+ * Nicht „die erste Zeile mit richtigen Umlauten“: ein Drucker mit nur PC437
+ * druckt Zeile 2 und 3 mit richtigen Umlauten, aber falschem € und §.
+ *
+ * Alles ausserhalb der Testzeilen steht mit Ersatzbuchstaben (reines ASCII),
+ * auch die Anleitung: „Lücke“ aus dem Katalog steht am Blatt als „Luecke“.
+ *
+ * Bildschirm und Papier zeigen dasselbe Blatt: `codeTableTestSheet` liefert
+ * es im Zeilenmodell des Beleg-Blatts (`ReceiptSheet`), `codeTableTestSheetBytes`
+ * druckt genau diese Zeilen. Das Blatt hat immer 32 Spalten (58 mm); auf
+ * 80 mm steht der Block ueber den linken Rand (`GS L`) mittig.
+ *
+ * Gemeinsamer Prueffall mit dem Dart-Zwilling:
+ * `fixtures/expected/code-table-test-sheet.{mm58,mm80}.hex` und `.lines.json`.
+ */
+import type { ReceiptSheet } from './blatt.js';
+import { type CodeTable, type CodeTableId } from '../printing/code-tables.js';
+import { type PosPaperSize, type RasterImage } from '../printing/escpos.js';
+/** Spalten des Testblatts -- immer 58-mm-Format. */
+export declare const CODE_TABLE_TEST_SHEET_CHARS = 32;
+export interface CodeTableTestSheetInput {
+    /** Kassen-Kennung fuer die Kopfzeile (keine Personendaten). */
+    cashregisterLabel: string;
+    /** Zeitpunkt des Drucks; die Kopfzeile zeigt ihn in Wiener Zeit. */
+    time: Date;
+    /** Papier des Druckers; das Blatt bleibt 32 Spalten, auf 80 mm mittig. */
+    paper: PosPaperSize;
+}
+/** Eine Testzeile: Nummer, Tabelle und die Zeichen, die ihr fehlen (fuer „ohne €“ am Bildschirm). */
+export interface CodeTableTestSheetRow {
+    readonly number: CodeTable['number'];
+    readonly codeTable: CodeTableId;
+    readonly missing: readonly string[];
+}
+/** Das Testblatt im Zeilenmodell des Beleg-Blatts, dazu die Testzeilen. */
+export interface CodeTableTestSheet extends ReceiptSheet {
+    readonly rows: readonly CodeTableTestSheetRow[];
+}
+/** Die Vorlage-Zeile als Rasterbild (384 x 24 Punkte), wie sie am Papier steht. */
+export declare function codeTableReferenceImage(): RasterImage;
+/** Das Testblatt im Zeilenmodell des Beleg-Blatts -- dieselben Zeilen wie am Papier. */
+export declare function codeTableTestSheet(options: CodeTableTestSheetInput): CodeTableTestSheet;
+/**
+ * Das Testblatt als ESC/POS-Bytes. Jede Testzeile schaltet nach ihrer
+ * Nummer einmal mit `FS .` + `ESC t n` auf ihre Tabelle und traegt deren Bytes (`encodeForCodeTable`,
+ * also das echte €-Byte, wo die Tabelle es hat). Die Nummer steht doppelt
+ * breit und hoch (`GS !`), die Vorlage als Rasterbild (`GS v 0`).
+ */
+export declare function codeTableTestSheetBytes(options: CodeTableTestSheetInput): Uint8Array;

package/dist/esm/receipt/code-table-test-sheet.js

@@ -0,0 +1,149 @@
+import { entpackeRasterBits } from './marke.js';
+import { toViennaWallClock } from '../vienna-time.js';
+import { labelText, messageText } from '../pos/texte.js';
+import { CODE_TABLES, encodeForCodeTable } from '../printing/code-tables.js';
+import { CODE_TABLE_REFERENCE_RASTER } from './code-table-reference-data.js';
+import { createEscPosDocument, escPosBytes, escPosCut, escPosRasterImage, escPosReset, escPosSetStyles, escPosText, wrapText, } from '../printing/escpos.js';
+/** Spalten des Testblatts -- immer 58-mm-Format. */
+export const CODE_TABLE_TEST_SHEET_CHARS = 32;
+/** Die zehn Zeichen der Vorlage, in der Reihenfolge des Katalogs. */
+const VORLAGE = ['ä', 'ö', 'ü', 'Ä', 'Ö', 'Ü', 'ß', '€', '§', '°'];
+/** Spalte des ersten Zeichens; danach jede zweite. Muss zu scripts/zeichensatz-vorlage.py passen. */
+const ERSTE_SPALTE = 5;
+/** Breite der Nummernzelle: eine Ziffer doppelt breit. */
+const NUMMER_SPALTEN = 2;
+const TRENNER = ' | ';
+/** Punkte je Blatt-Zeile: 32 Zeichen zu 12 Punkten. */
+const BLATT_PUNKTE = CODE_TABLE_TEST_SHEET_CHARS * 12;
+/** Linker Rand, der den 32-Spalten-Block auf 80 mm (576 Punkte) mittig setzt. */
+const RAND_80 = (576 - BLATT_PUNKTE) / 2;
+const GS = 0x1d;
+const ESC = 0x1b;
+/** `ESC t` der Vorgabe ohne gewaehlte Tabelle (WPC1252). */
+const VORGABE_ESC_T = 16;
+/** Die Vorlage-Zeile als Rasterbild (384 x 24 Punkte), wie sie am Papier steht. */
+export function codeTableReferenceImage() {
+    const r = CODE_TABLE_REFERENCE_RASTER;
+    return entpackeRasterBits(r.bits, r.width, r.height);
+}
+/** Text in reines ASCII (Ersatzbuchstaben): steht auf jedem Drucker gleich, egal welche Tabelle gilt. */
+function nurAscii(text) {
+    return String.fromCharCode(...encodeForCodeTable(text, 'replacement'));
+}
+function zeile(text, bold = false, ausrichtung = 'left') {
+    const rest = CODE_TABLE_TEST_SHEET_CHARS - text.length;
+    const links = ausrichtung === 'center' ? Math.floor(rest / 2) : 0;
+    return { kind: 'line', text: ' '.repeat(links) + text + ' '.repeat(rest - links), bold, blank: false };
+}
+function zeilen(text, bold = false, ausrichtung = 'left') {
+    return wrapText(nurAscii(text), CODE_TABLE_TEST_SHEET_CHARS).map((t) => zeile(t, bold, ausrichtung));
+}
+/** Die Zeichen einer Tabelle an ihren Spalten; ein fehlendes Zeichen laesst seine Luecke. */
+function zeichenDerTabelle(tabelle) {
+    return VORLAGE.map((z) => (tabelle.missing.includes(z) ? ' ' : z)).join(' ').trimEnd();
+}
+function nummernZeile(nummer, text) {
+    const kopf = String(nummer).padStart(NUMMER_SPALTEN, ' ') + TRENNER;
+    return { ...zeile(kopf + text), doubleSizeLead: NUMMER_SPALTEN };
+}
+const zweistellig = (n) => String(n).padStart(2, '0');
+/** Das Testblatt im Zeilenmodell des Beleg-Blatts -- dieselben Zeilen wie am Papier. */
+export function codeTableTestSheet(options) {
+    return blattBauen(options).blatt;
+}
+/**
+ * Baut das Blatt und merkt sich dabei, welcher Block die Vorlage-Zeile ist.
+ * Die Bytes suchen sie nicht am Text (der ist `nurAscii` und kann sich
+ * aendern), sondern nehmen genau diese Stelle.
+ */
+function blattBauen(options) {
+    const z = CODE_TABLE_TEST_SHEET_CHARS;
+    const uhr = toViennaWallClock(options.time);
+    const zeit = `${zweistellig(uhr.day)}.${zweistellig(uhr.month)}. ${zweistellig(uhr.hour)}:${zweistellig(uhr.minute)}`;
+    const doppelt = zeile('='.repeat(z));
+    const einfach = zeile('-'.repeat(z));
+    const einzug = ' '.repeat(ERSTE_SPALTE);
+    const bloecke = [
+        doppelt,
+        ...zeilen(labelText('codetable.title'), true, 'center'),
+        ...zeilen(`${options.cashregisterLabel.trim()}  ${zeit}`, false, 'center'),
+        doppelt,
+        ...zeilen(labelText('codetable.reference')),
+    ];
+    // Am Papier ein Bild (`codeTableReferenceImage`), am Bildschirm Text.
+    const vorlage = bloecke.length;
+    bloecke.push(zeile(einzug + VORLAGE.join(' ')), einfach);
+    const ersatz = CODE_TABLES.find((t) => t.id === 'replacement');
+    for (const t of CODE_TABLES) {
+        if (t === ersatz)
+            continue;
+        bloecke.push(nummernZeile(t.number, zeichenDerTabelle(t)));
+    }
+    bloecke.push(einfach);
+    const ersatzText = String.fromCharCode(...encodeForCodeTable(VORLAGE.join(' '), 'replacement'));
+    const [ersteErsatz = '', ...restErsatz] = wrapText(ersatzText, z - ERSTE_SPALTE);
+    bloecke.push(nummernZeile(ersatz.number, ersteErsatz));
+    for (const t of restErsatz)
+        bloecke.push(zeile(einzug + t));
+    bloecke.push(zeile(einzug + nurAscii(labelText('codetable.replacement_note'))));
+    bloecke.push(doppelt);
+    bloecke.push(...zeilen(labelText('codetable.instruction_title'), true));
+    bloecke.push(...zeilen(messageText('codetable.instruction')));
+    bloecke.push(...zeilen(messageText('codetable.instruction_none', { number: ersatz.number })));
+    bloecke.push(doppelt);
+    return {
+        blatt: {
+            charsPerLine: z,
+            blocks: bloecke,
+            rows: CODE_TABLES.map((t) => ({ number: t.number, codeTable: t.id, missing: t.missing })),
+        },
+        vorlage,
+    };
+}
+/**
+ * Das Testblatt als ESC/POS-Bytes. Jede Testzeile schaltet nach ihrer
+ * Nummer einmal mit `FS .` + `ESC t n` auf ihre Tabelle und traegt deren Bytes (`encodeForCodeTable`,
+ * also das echte €-Byte, wo die Tabelle es hat). Die Nummer steht doppelt
+ * breit und hoch (`GS !`), die Vorlage als Rasterbild (`GS v 0`).
+ */
+export function codeTableTestSheetBytes(options) {
+    const { blatt, vorlage: vorlageIndex } = blattBauen(options);
+    const vorlage = blatt.blocks[vorlageIndex];
+    if (vorlage === undefined || vorlage.kind !== 'line')
+        throw new Error(`Testblatt: Vorlage-Zeile fehlt (Block ${vorlageIndex})`);
+    // Das Dokument ist immer 58 mm: 32 Spalten, Druckbereich 384 Punkte.
+    const doc = createEscPosDocument({ paperSize: 'mm58', codeTable: null });
+    escPosReset(doc);
+    if (options.paper === 'mm80')
+        doc.bytes.push(GS, 0x4c, RAND_80 & 0xff, RAND_80 >> 8);
+    let tabellen = 0;
+    for (const block of blatt.blocks) {
+        if (block.kind !== 'line')
+            continue;
+        if (block === vorlage) {
+            escPosRasterImage(doc, codeTableReferenceImage(), { align: 'left' });
+            continue;
+        }
+        if (block.doubleSizeLead === undefined) {
+            escPosText(doc, block.text.trimEnd(), { styles: { align: 'left', bold: block.bold } });
+            continue;
+        }
+        const tabelle = blatt.rows[tabellen];
+        tabellen += 1;
+        const nummer = block.text.slice(0, block.doubleSizeLead).trim();
+        // Die Ziffer ist ASCII und steht in jeder Tabelle gleich: keine Umschaltung
+        // davor, die Zeile schaltet genau einmal, vor ihren eigenen Bytes.
+        escPosSetStyles(doc, { align: 'left', bold: true, width: 2, height: 2 });
+        doc.bytes.push(...encodeForCodeTable(nummer, 'replacement'));
+        escPosSetStyles(doc, { align: 'left', codeTable: tabelle.codeTable });
+        doc.bytes.push(...encodeForCodeTable(block.text.slice(block.doubleSizeLead).trimEnd(), tabelle.codeTable), 0x0a);
+    }
+    // Endzustand wie ohne Wahl: Tabelle 16 (WPC1252) und auf 80 mm Rand 0.
+    // Ein Druck danach ohne `ESC @` steht sonst in der Tabelle der letzten
+    // Testzeile und um den Rand verschoben.
+    doc.bytes.push(ESC, 0x74, VORGABE_ESC_T);
+    if (options.paper === 'mm80')
+        doc.bytes.push(GS, 0x4c, 0, 0);
+    escPosCut(doc, 'full');
+    return escPosBytes(doc);
+}

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

@@ -6,4 +6,5 @@ export { type SheetLogoSize, type SheetLogo, type LogoDimensions, type SheetBloc
 export { rasterizeLogo } from './bild.js';
 export { type BrandMarkRaster, BRAND_MARK_RASTERS, BRAND_MARK_PATHS } from './marke-daten.js';
 export { brandMarkImage } from './marke.js';
+export { type CodeTableTestSheetInput, type CodeTableTestSheetRow, type CodeTableTestSheet, CODE_TABLE_TEST_SHEET_CHARS, codeTableTestSheet, codeTableTestSheetBytes, codeTableReferenceImage, } from './code-table-test-sheet.js';
 export { type ReceiptDueTip, type ReceiptDueTipRecipient, type ReceiptDueOptions, type ReceiptDueBuckets, type ReceiptDueBreakdown, type ReceiptDueErrorReason, receiptDueCents, receiptDueBreakdown, ReceiptDueError, RECEIPT_DUE_ERROR_REASONS, isReceiptDueError, } from './due.js';

package/dist/esm/receipt/index.js

@@ -6,4 +6,5 @@ export { SHEET_LOGO_SIZES, LOGO_MAX_PIXELS, DOTS_PER_CHAR, DOTS_PER_LINE, paperS
 export { rasterizeLogo } from './bild.js';
 export { BRAND_MARK_RASTERS, BRAND_MARK_PATHS } from './marke-daten.js';
 export { brandMarkImage } from './marke.js';
+export { CODE_TABLE_TEST_SHEET_CHARS, codeTableTestSheet, codeTableTestSheetBytes, codeTableReferenceImage, } from './code-table-test-sheet.js';
 export { receiptDueCents, receiptDueBreakdown, ReceiptDueError, RECEIPT_DUE_ERROR_REASONS, isReceiptDueError, } from './due.js';

package/dist/esm/receipt/layout-escpos.d.ts

@@ -55,7 +55,12 @@ export declare function blattFuerDruck(layout: ReceiptLayout, optionen: {
 export interface EscPosLayoutOptions {
     /** Papierbreite; Vorgabe ist die des Layouts (dessen Spaltenbreiten daran haengen). */
     paperSize?: PosPaperSize;
-    /** Codepage des Druckers, Vorgabe `CP1252`; `null` laesst die des Geraets stehen. */
+    /**
+     * Codepage des Druckers, Vorgabe `CP1252`; `null` laesst die des Geraets
+     * stehen. Eine Tabelle des Katalogs (`CodeTableId`, im Drucker-Wizard
+     * gewaehlt) druckt `€`, `§`, `°` als echtes Byte, wo die Tabelle sie hat,
+     * sonst als Ersatzbuchstaben; ohne Wahl bleibt der Bon byte-gleich.
+     */
     codeTable?: PosCodeTable | null;
     /** Papierschnitt am Ende: `true` (voll), `'partial'` oder `false`. Vorgabe `true`. */
     cut?: boolean | PosCutMode;

package/dist/esm/receipt/layout-escpos.js

@@ -34,17 +34,21 @@ export function blattFuerDruck(layout, optionen) {
 /**
  * Druckbar gemachtes Layout: Texte durch [escPosPrintableText] (Codepage,
  * "EUR" statt "€", Striche), damit das Raster mit den Zeichen rechnet, die
- * wirklich aufs Papier gehen. Der QR-Inhalt bleibt unveraendert.
+ * wirklich aufs Papier gehen. Mit gewaehlter Tabelle bleibt "€", wo die
+ * Tabelle es hat, und fehlende Zeichen werden schon hier zu
+ * Ersatzbuchstaben: jedes Zeichen ist danach genau ein Byte. Der QR-Inhalt
+ * bleibt unveraendert.
  */
-function druckbaresLayout(layout) {
+function druckbaresLayout(layout, codeTable) {
+    const druckbar = (text) => escPosPrintableText(text, codeTable);
     return {
         ...layout,
         lines: layout.lines.map((z) => {
             switch (z.kind) {
-                case 'text': return { ...z, text: escPosPrintableText(z.text) };
-                case 'banner': return { ...z, text: escPosPrintableText(z.text) };
-                case 'columns': return { ...z, columns: z.columns.map((c) => ({ ...c, text: escPosPrintableText(c.text) })) };
-                case 'rule': return { ...z, char: escPosPrintableText(z.char) || '-' };
+                case 'text': return { ...z, text: druckbar(z.text) };
+                case 'banner': return { ...z, text: druckbar(z.text) };
+                case 'columns': return { ...z, columns: z.columns.map((c) => ({ ...c, text: druckbar(c.text) })) };
+                case 'rule': return { ...z, char: druckbar(z.char) || '-' };
                 default: return z;
             }
         }),
@@ -134,7 +138,7 @@ export function escPosLayoutResult(layout, options = {}) {
     };
     // `blattFuerDruck` prueft das Logo-Raster bereits VOR der Rueckgabe -- die
     // Schleife unten schreibt darum nie ein Byte auf ein falsch grosses Logo.
-    const blatt = blattFuerDruck(druckbaresLayout(layout), {
+    const blatt = blattFuerDruck(druckbaresLayout(layout, options.codeTable), {
         zeichen: CHARS_PER_PAPER_SIZE[paperSize],
         logo: options.logo,
         marke: options.brandMark,

package/dist/esm/version.d.ts

@@ -4,4 +4,4 @@
  * Client-Version, Nachtrag §6). Ein Test haelt sie gleich mit `package.json`;
  * beim Anheben der Version beide Stellen aendern.
  */
-export declare const PACKAGE_VERSION = "1.0.0";
+export declare const PACKAGE_VERSION = "1.1.1";

package/dist/esm/version.js

@@ -4,4 +4,4 @@
  * Client-Version, Nachtrag §6). Ein Test haelt sie gleich mit `package.json`;
  * beim Anheben der Version beide Stellen aendern.
  */
-export const PACKAGE_VERSION = '1.0.0';
+export const PACKAGE_VERSION = '1.1.1';

package/fixtures/code-table-preview.json

@@ -0,0 +1,14 @@
+{
+  "sample": [
+    "Käsekrainer 3,50 €",
+    "Tee 80°"
+  ],
+  "tables": {
+    "wpc1252": "Käsekrainer 3,50 €\nTee 80°",
+    "pc858": "Käsekrainer 3,50 €\nTee 80°",
+    "pc850": "Käsekrainer 3,50 EUR\nTee 80°",
+    "pc437": "Käsekrainer 3,50 EUR\nTee 80°",
+    "iso8859_15": "Käsekrainer 3,50 €\nTee 80°",
+    "replacement": "Kaesekrainer 3,50 EUR\nTee 80Grad"
+  }
+}

package/fixtures/code-table-receipts.json

@@ -0,0 +1,84 @@
+{
+  "version": 1,
+  "_note": "Receipts per code table: ESC/POS bytes of each case for every table in code-tables.json, written by `npm run fixtures:zeichensatz` to expected/code-table-receipt.<case>.<table>.hex (32 bytes per line). A case names a golden receipt under receipts/ or carries its own input. Print options: escPosLayoutBytes(layout, { codeTable }), everything else default.",
+  "tables": [
+    "wpc1252",
+    "pc858",
+    "pc850",
+    "pc437",
+    "iso8859_15",
+    "replacement"
+  ],
+  "cases": [
+    {
+      "name": "sale-cash",
+      "receipt": "sale-cash"
+    },
+    {
+      "name": "test-cashregister-sale",
+      "receipt": "test-cashregister-sale"
+    },
+    {
+      "name": "long-item-name",
+      "receipt": "long-item-name"
+    },
+    {
+      "name": "special-characters",
+      "input": {
+        "company": {
+          "companyName": "Bäckerei Muster",
+          "street": "Hauptplatz 1",
+          "zip": "4830",
+          "city": "Hallstatt",
+          "phone": "+43 6134 12345",
+          "vatId": "ATU12345678",
+          "taxNumber": "",
+          "isSmallBusiness": false,
+          "footer1": "Preise in € inkl. USt., Pfand nach § 3",
+          "footer2": "Danke & auf Wiedersehen",
+          "thanksMessage": [],
+          "showKreiseckLogo": false
+        },
+        "receipt": {
+          "receiptId": "AT0-KASSE1-43",
+          "cashregisterId": "KASSE1",
+          "timeStamp": "2026-08-13T10:15:30",
+          "items": [
+            {
+              "name": "Tee 80° heiß",
+              "quantity": 2,
+              "unitPriceCents": 320,
+              "vatRate": 10
+            },
+            {
+              "name": "Pfand § 3 Mehrweg",
+              "quantity": 1,
+              "unitPriceCents": 100,
+              "vatRate": 20
+            },
+            {
+              "name": "Grüner Öl-Kürbis Größe XL",
+              "quantity": 1,
+              "unitPriceCents": 1250,
+              "vatRate": 10
+            }
+          ],
+          "vouchers": [],
+          "paymentMethod": "cash",
+          "turnoverCounterAES256ICM": "UMSATZ",
+          "signaturePreviousReceipt": "VORGAENGER",
+          "certificateSerialNumber": "6F0404F0",
+          "receiptType": "standard",
+          "sig": "eyJhbGciOiJFUzI1NiJ9.QVQx.SIGNATURWERT",
+          "qr": "_R1-AT1_KASSE1_AT0-KASSE1-43_2026-08-13T10:15:30_5,00_2,70_0,00_0,00_0,00_UMSATZ_VORGAENGER_6F0404F0_SIGNATUR",
+          "fullReceiptId": "VOLL",
+          "customerDetails": [],
+          "legalMessage": []
+        },
+        "options": {
+          "paperSize": "mm58"
+        }
+      }
+    }
+  ]
+}

package/fixtures/code-tables.json

@@ -0,0 +1,12 @@
+{
+  "version": 1,
+  "characters": ["ä","ö","ü","Ä","Ö","Ü","ß","€","§","°"],
+  "tables": [
+    {"id":"wpc1252","number":1,"escT":16,"bytes":{"ä":"E4","ö":"F6","ü":"FC","Ä":"C4","Ö":"D6","Ü":"DC","ß":"DF","€":"80","§":"A7","°":"B0"}},
+    {"id":"pc858","number":2,"escT":19,"bytes":{"ä":"84","ö":"94","ü":"81","Ä":"8E","Ö":"99","Ü":"9A","ß":"E1","€":"D5","§":"F5","°":"F8"}},
+    {"id":"pc850","number":3,"escT":2,"bytes":{"ä":"84","ö":"94","ü":"81","Ä":"8E","Ö":"99","Ü":"9A","ß":"E1","€":"455552","§":"F5","°":"F8"}},
+    {"id":"pc437","number":4,"escT":0,"bytes":{"ä":"84","ö":"94","ü":"81","Ä":"8E","Ö":"99","Ü":"9A","ß":"E1","€":"455552","§":"5061722E","°":"F8"}},
+    {"id":"iso8859_15","number":5,"escT":40,"bytes":{"ä":"E4","ö":"F6","ü":"FC","Ä":"C4","Ö":"D6","Ü":"DC","ß":"DF","€":"A4","§":"A7","°":"B0"}},
+    {"id":"replacement","number":6,"escT":0,"bytes":{"ä":"6165","ö":"6F65","ü":"7565","Ä":"4165","Ö":"4F65","Ü":"5565","ß":"7373","€":"455552","§":"5061722E","°":"47726164"}}
+  ]
+}

package/fixtures/expected/code-table-receipt.long-item-name.iso8859_15.hex

@@ -0,0 +1,27 @@
+1b401d4c00001d5780011b74281b45011c2e1b7428202020202020202042e463
+6b65726569204d75737465720a1b45001c2e1b74282020202020202020202048
+61757074706c61747a20310a1c2e1b7428202020202020202020343833302048
+616c6c73746174740a1c2e1b7428202020202020202020204154553132333435
+3637380a1c2e1b74282020202020202020202b34332036313334203132333435
+0a1b64011c2e1b7428446174756d3a2020202020202031332e30382e32303236
+2031303a31353a33300a1c2e1b74284b617373656e2d49443a20202020202020
+2020202020202020204b41535345310a1c2e1b742842656c65672d49443a2020
+20202020202020204154302d4b41535345312d34320a1b64011c2e1b74283220
+2078204861757367656d6163687465202020202020202020322c393820420a1c
+2e1b742842696f2d44696e6b656c766f6c6c6b6f726e73656d6d656c206d6974
+0a1c2e1b74284bfc726269736b65726e656e20756e640a1c2e1b7428536f6e6e
+656e626c756d656e6b65726e656e206a6520312c34390a1b64011c2e1b74284d
+775374252020204d775374202020204e6574746f202020202042727574746f0a
+1c2e1b74284220313025202020302c323720202020322c373120202020202020
+20322c39380a1c2e1b74282d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d
+2d2d2d2d2d2d2d2d2d2d2d0a1c2e1b7428476573616d743a2020202020202020
+2020202020202020202020322c393820a40a1c2e1b74285a61686c756e677361
+72743a202020202020202020204261727a61686c756e670a1b64011b61311c2e
+1b74281d286b03003143061d286b03003145311d286b70003150305f52312d41
+54315f4b41535345315f4154302d4b41535345312d34325f323032362d30382d
+31335431303a31353a33305f352c30305f322c37305f302c30305f302c30305f
+302c30305f554d5341545a5f564f524741454e4745525f36463034303446305f
+5349474e415455521d286b03003152301d286b03003151301b64011b61301c2e
+1b7428205669656c656e2044616e6b2066fc7220496872656e2045696e6b6175
+660a1c2e1b7428202020207777772e626165636b657265692d6d75737465722e
+61740a0a0a0a0a0a1d5630

package/fixtures/expected/code-table-receipt.long-item-name.pc437.hex

@@ -0,0 +1,27 @@
+1b401d4c00001d5780011b74001b45011c2e1b74002020202020202020428463
+6b65726569204d75737465720a1b45001c2e1b74002020202020202020202048
+61757074706c61747a20310a1c2e1b7400202020202020202020343833302048
+616c6c73746174740a1c2e1b7400202020202020202020204154553132333435
+3637380a1c2e1b74002020202020202020202b34332036313334203132333435
+0a1b64011c2e1b7400446174756d3a2020202020202031332e30382e32303236
+2031303a31353a33300a1c2e1b74004b617373656e2d49443a20202020202020
+2020202020202020204b41535345310a1c2e1b740042656c65672d49443a2020
+20202020202020204154302d4b41535345312d34320a1b64011c2e1b74003220
+2078204861757367656d6163687465202020202020202020322c393820420a1c
+2e1b740042696f2d44696e6b656c766f6c6c6b6f726e73656d6d656c206d6974
+0a1c2e1b74004b81726269736b65726e656e20756e640a1c2e1b7400536f6e6e
+656e626c756d656e6b65726e656e206a6520312c34390a1b64011c2e1b74004d
+775374252020204d775374202020204e6574746f202020202042727574746f0a
+1c2e1b74004220313025202020302c323720202020322c373120202020202020
+20322c39380a1c2e1b74002d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d
+2d2d2d2d2d2d2d2d2d2d2d0a1c2e1b7400476573616d743a2020202020202020
+202020202020202020322c3938204555520a1c2e1b74005a61686c756e677361
+72743a202020202020202020204261727a61686c756e670a1b64011b61311c2e
+1b74001d286b03003143061d286b03003145311d286b70003150305f52312d41
+54315f4b41535345315f4154302d4b41535345312d34325f323032362d30382d
+31335431303a31353a33305f352c30305f322c37305f302c30305f302c30305f
+302c30305f554d5341545a5f564f524741454e4745525f36463034303446305f
+5349474e415455521d286b03003152301d286b03003151301b64011b61301c2e
+1b7400205669656c656e2044616e6b2066817220496872656e2045696e6b6175
+660a1c2e1b7400202020207777772e626165636b657265692d6d75737465722e
+61740a0a0a0a0a0a1d5630

package/fixtures/expected/code-table-receipt.long-item-name.pc850.hex

@@ -0,0 +1,27 @@
+1b401d4c00001d5780011b74021b45011c2e1b74022020202020202020428463
+6b65726569204d75737465720a1b45001c2e1b74022020202020202020202048
+61757074706c61747a20310a1c2e1b7402202020202020202020343833302048
+616c6c73746174740a1c2e1b7402202020202020202020204154553132333435
+3637380a1c2e1b74022020202020202020202b34332036313334203132333435
+0a1b64011c2e1b7402446174756d3a2020202020202031332e30382e32303236
+2031303a31353a33300a1c2e1b74024b617373656e2d49443a20202020202020
+2020202020202020204b41535345310a1c2e1b740242656c65672d49443a2020
+20202020202020204154302d4b41535345312d34320a1b64011c2e1b74023220
+2078204861757367656d6163687465202020202020202020322c393820420a1c
+2e1b740242696f2d44696e6b656c766f6c6c6b6f726e73656d6d656c206d6974
+0a1c2e1b74024b81726269736b65726e656e20756e640a1c2e1b7402536f6e6e
+656e626c756d656e6b65726e656e206a6520312c34390a1b64011c2e1b74024d
+775374252020204d775374202020204e6574746f202020202042727574746f0a
+1c2e1b74024220313025202020302c323720202020322c373120202020202020
+20322c39380a1c2e1b74022d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d
+2d2d2d2d2d2d2d2d2d2d2d0a1c2e1b7402476573616d743a2020202020202020
+202020202020202020322c3938204555520a1c2e1b74025a61686c756e677361
+72743a202020202020202020204261727a61686c756e670a1b64011b61311c2e
+1b74021d286b03003143061d286b03003145311d286b70003150305f52312d41
+54315f4b41535345315f4154302d4b41535345312d34325f323032362d30382d
+31335431303a31353a33305f352c30305f322c37305f302c30305f302c30305f
+302c30305f554d5341545a5f564f524741454e4745525f36463034303446305f
+5349474e415455521d286b03003152301d286b03003151301b64011b61301c2e
+1b7402205669656c656e2044616e6b2066817220496872656e2045696e6b6175
+660a1c2e1b7402202020207777772e626165636b657265692d6d75737465722e
+61740a0a0a0a0a0a1d5630

package/fixtures/expected/code-table-receipt.long-item-name.pc858.hex

@@ -0,0 +1,27 @@
+1b401d4c00001d5780011b74131b45011c2e1b74132020202020202020428463
+6b65726569204d75737465720a1b45001c2e1b74132020202020202020202048
+61757074706c61747a20310a1c2e1b7413202020202020202020343833302048
+616c6c73746174740a1c2e1b7413202020202020202020204154553132333435
+3637380a1c2e1b74132020202020202020202b34332036313334203132333435
+0a1b64011c2e1b7413446174756d3a2020202020202031332e30382e32303236
+2031303a31353a33300a1c2e1b74134b617373656e2d49443a20202020202020
+2020202020202020204b41535345310a1c2e1b741342656c65672d49443a2020
+20202020202020204154302d4b41535345312d34320a1b64011c2e1b74133220
+2078204861757367656d6163687465202020202020202020322c393820420a1c
+2e1b741342696f2d44696e6b656c766f6c6c6b6f726e73656d6d656c206d6974
+0a1c2e1b74134b81726269736b65726e656e20756e640a1c2e1b7413536f6e6e
+656e626c756d656e6b65726e656e206a6520312c34390a1b64011c2e1b74134d
+775374252020204d775374202020204e6574746f202020202042727574746f0a
+1c2e1b74134220313025202020302c323720202020322c373120202020202020
+20322c39380a1c2e1b74132d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d
+2d2d2d2d2d2d2d2d2d2d2d0a1c2e1b7413476573616d743a2020202020202020
+2020202020202020202020322c393820d50a1c2e1b74135a61686c756e677361
+72743a202020202020202020204261727a61686c756e670a1b64011b61311c2e
+1b74131d286b03003143061d286b03003145311d286b70003150305f52312d41
+54315f4b41535345315f4154302d4b41535345312d34325f323032362d30382d
+31335431303a31353a33305f352c30305f322c37305f302c30305f302c30305f
+302c30305f554d5341545a5f564f524741454e4745525f36463034303446305f
+5349474e415455521d286b03003152301d286b03003151301b64011b61301c2e
+1b7413205669656c656e2044616e6b2066817220496872656e2045696e6b6175
+660a1c2e1b7413202020207777772e626165636b657265692d6d75737465722e
+61740a0a0a0a0a0a1d5630