@kreiseck/kasseneck-api 1.0.0 → 1.1.1

package/CHANGELOG.md

@@ -4,6 +4,73 @@ Was vor 0.7.0 geschah, steht in der Commit-Historie (`git log`); ab hier wird
 es hier geführt. Ein Eintrag nennt die Änderung **und ihren Grund** —
 nur der Grund überlebt den nächsten Umbau.
 
+## 1.1.1
+
+The code-table test sheet asks for the right row. Reason: a Bluetooth
+printer that only knows PC437 printed rows 2 and 3 with correct umlauts but
+wrong glyphs for `€` and `§` (`╒`, `⌡`), and row 4 correct with gaps for
+`€` and `§`. "The first row that looks exactly like above" confused users,
+and "the row with correct umlauts" would pick row 2. The rule now is: the
+row with no wrong character; a gap is fine; if several fit, the one with
+the fewest gaps; if none fits, 6.
+
+Additive, no breaking change; receipts are byte for byte the same (the 24
+`code-table-receipt.*.hex` files are unchanged).
+
+- **Test sheet** (`./receipt`): reference heading `codetable.reference` is
+  now "So sehen die Zeichen richtig aus" (32 columns; with a colon it would
+  wrap), the footer is the new rule: `codetable.instruction_title` (bold),
+  `codetable.instruction`, `codetable.instruction_none` ("Passt keine:
+  {number}.", the replacement row). As before, everything outside the test
+  rows prints with replacement letters (pure ASCII), so "Lücke" from the
+  catalogue stands as "Luecke" on the sheet, on paper and in the line model.
+  Rows, big numbers, margins and the end reset are unchanged. Contract:
+  `fixtures/expected/code-table-test-sheet.*`.
+- **Screen texts** (`fixtures/pos-texts.json`): `codetable.question` is now
+  "In welcher Zeile steht kein falsches Zeichen?"; new
+  `codetable.question_hint`, `codetable.preview_title`, `codetable.apply`,
+  `codetable.other_row`.
+- **Preview** (`./printing`): `codeTablePreviewText(table)` returns the
+  sample "Käsekrainer 3,50 €" / "Tee 80°" as it prints with that table
+  (lines joined by `\n`), e.g. `pc437` gives "Käsekrainer 3,50 EUR", so the
+  user sees the effect of a row before applying it. Shared contract with the
+  Dart twin: `fixtures/code-table-preview.json`.
+
+## 1.1.0
+
+Receipt printers that print umlauts and special characters correctly.
+Reason: `ESC t n` selects the character table, but the number n differs
+between manufacturers; many low-cost printers ignore `ESC t 16` or put
+another table there and print garbage instead of `ä`. The printer wizard
+now prints a test sheet, the user taps the first row that looks right, and
+the register keeps that choice per printer on the device.
+
+Additive, no breaking change. Without a chosen table every receipt is byte
+for byte the same as in 1.0.0 (all golden receipts unchanged).
+
+- **Code-table catalogue** (`./printing`): `CodeTableId`, `CodeTable`,
+  `CODE_TABLES` (six tables: `wpc1252` = `ESC t 16`, `pc858` = 19,
+  `pc850` = 2, `pc437` = 0, `iso8859_15` = 40, `replacement` = 0),
+  `codeTableById`, `codeTableFromSetting`, `encodeForCodeTable`. For
+  ä ö ü Ä Ö Ü ß € § ° every table answers with its own byte or, where the
+  table lacks the character, with replacement letters (`ae`, `EUR`, `Par.`,
+  `Grad`), never `?`. Shared contract with the Dart twin:
+  `fixtures/code-tables.json`.
+- **Test sheet** (`./receipt`): `codeTableTestSheet` (line model for the
+  screen, 32 columns) and `codeTableTestSheetBytes` (ESC/POS, centred on
+  80 mm), `codeTableReferenceImage`. Contract:
+  `fixtures/expected/code-table-test-sheet.*`. New texts in
+  `fixtures/pos-texts.json` (`codetable.*`).
+- **Receipts with a chosen table**: `escPosLayoutBytes(layout, { codeTable })`
+  accepts a `CodeTableId`. `€`, `§` and `°` go out as the table's real
+  byte where the table has them, otherwise as replacement letters. Missing
+  characters are replaced in the text before the columns are laid out, so
+  a character that becomes several letters never shifts a column.
+  `escPosPrintableText(text, codeTable?)` takes the same optional table;
+  without it (or with `null`/`CP1252`) it behaves as before.
+- **`CP437` and `§`**: on the old `CP437` name `§` now prints as `Par.`
+  (was `?`), with the columns measured after the replacement.
+
 ## 1.0.0
 
 The package speaks the English API `/v3` and nothing else, and its own

package/dist/cjs/pos/texte.d.ts

@@ -469,6 +469,19 @@ declare const MELDUNGEN_ROH: {
     readonly 'print.wizard_cancelled': {
         readonly text: "Nichts gespeichert.";
     };
+    readonly 'codetable.question': {
+        readonly text: "In welcher Zeile steht kein falsches Zeichen?";
+    };
+    readonly 'codetable.question_hint': {
+        readonly text: "Lücken sind in Ordnung.";
+    };
+    readonly 'codetable.instruction': {
+        readonly text: "Die Zeile, in der KEIN falsches Zeichen steht. Eine Lücke ist in Ordnung. Passen mehrere, die mit den wenigsten Lücken.";
+    };
+    readonly 'codetable.instruction_none': {
+        readonly text: "Passt keine: {number}.";
+        readonly placeholders: readonly ["number"];
+    };
     readonly 'bluetooth.off': {
         readonly text: "Bluetooth ist ausgeschaltet. Bitte einschalten und erneut suchen.";
         readonly only: readonly ["app"];
@@ -964,6 +977,44 @@ declare const BESCHRIFTUNGEN_ROH: {
     readonly 'cancellation.difference': {
         readonly text: "Differenz";
     };
+    readonly 'codetable.title': {
+        readonly text: "ZEICHENSATZ-TEST";
+    };
+    readonly 'codetable.reference': {
+        readonly text: "So sehen die Zeichen richtig aus";
+    };
+    readonly 'codetable.replacement_note': {
+        readonly text: "(Ersatz, passt immer)";
+    };
+    readonly 'codetable.missing': {
+        readonly text: "ohne {chars}";
+        readonly placeholders: readonly ["chars"];
+    };
+    readonly 'codetable.print_again': {
+        readonly text: "Nochmal drucken";
+    };
+    readonly 'codetable.not_checked': {
+        readonly text: "Umlaute noch nicht geprüft";
+    };
+    readonly 'codetable.check': {
+        readonly text: "Umlaute prüfen";
+    };
+    readonly 'codetable.current': {
+        readonly text: "Zeichensatz: Nr. {number}";
+        readonly placeholders: readonly ["number"];
+    };
+    readonly 'codetable.instruction_title': {
+        readonly text: "Welche Zeile nehmen?";
+    };
+    readonly 'codetable.preview_title': {
+        readonly text: "So steht es dann am Bon:";
+    };
+    readonly 'codetable.apply': {
+        readonly text: "Übernehmen";
+    };
+    readonly 'codetable.other_row': {
+        readonly text: "Andere Zeile";
+    };
 };
 export type LabelKey = keyof typeof BESCHRIFTUNGEN_ROH;
 export declare const LABELS: Record<LabelKey, TextEntry>;

package/dist/cjs/pos/texte.js

@@ -255,6 +255,18 @@ const MELDUNGEN_ROH = {
     // Abbrechen an jeder Stelle: nichts gespeichert. Der Satz sagt genau das,
     // damit niemand einen halb eingerichteten Drucker vermutet.
     'print.wizard_cancelled': { text: 'Nichts gespeichert.' },
+    // Zeichensatz-Test im Drucker-Wizard: das Testblatt nennt die Anleitung,
+    // der Bildschirm stellt die Frage daneben. Die Regel ist „kein falsches
+    // Zeichen“, nicht „erste Zeile“ und nicht „Umlaute richtig“: ein Drucker
+    // mit nur PC437 druckt Zeile 2 und 3 mit richtigen Umlauten, aber falschem
+    // € und § (╒, ⌡); richtig ist dort Zeile 4, mit Luecken fuer € und §.
+    // Am Papier steht „Lücke“ als „Luecke“ (Ersatzbuchstaben wie jeder Text
+    // ausserhalb der Testzeilen), am Bildschirm mit Umlaut.
+    'codetable.question': { text: 'In welcher Zeile steht kein falsches Zeichen?' },
+    'codetable.question_hint': { text: 'Lücken sind in Ordnung.' },
+    'codetable.instruction': { text: 'Die Zeile, in der KEIN falsches Zeichen steht. Eine Lücke ist in Ordnung. Passen mehrere, die mit den wenigsten Lücken.' },
+    // `{number}` ist die Ersatz-Zeile (6), die immer passt.
+    'codetable.instruction_none': { text: 'Passt keine: {number}.', placeholders: ['number'] },
     'bluetooth.off': { text: 'Bluetooth ist ausgeschaltet. Bitte einschalten und erneut suchen.', only: ['app'] },
     'bluetooth.permission_missing': { text: 'Bitte die Freigabe in den Geräte-Einstellungen erteilen.', only: ['app'] },
     'bluetooth.search_failed': { text: 'Die Suche ist fehlgeschlagen: {reason}', placeholders: ['reason'], only: ['app'] },
@@ -566,6 +578,26 @@ const BESCHRIFTUNGEN_ROH = {
     'cancellation.all_cash': { text: 'Alles bar' },
     'cancellation.payment_remainder': { text: 'Rest {amount}', placeholders: ['amount'] },
     'cancellation.difference': { text: 'Differenz' },
+    // --- Zeichensatz-Test (Testblatt und Drucker & Lade) ----------------------
+    // Das Testblatt druckt diese Texte mit Ersatzbuchstaben (reines ASCII);
+    // die Knoepfe stehen nur am Bildschirm. `{chars}` sind die fehlenden Zeichen einer Zeile
+    // („€“ bzw. „€ §“), `{number}` die gewaehlte Zeile (1-6).
+    'codetable.title': { text: 'ZEICHENSATZ-TEST' },
+    // Genau 32 Spalten: mit Doppelpunkt waeren es 33, die Ueberschrift braeche um.
+    'codetable.reference': { text: 'So sehen die Zeichen richtig aus' },
+    'codetable.replacement_note': { text: '(Ersatz, passt immer)' },
+    'codetable.missing': { text: 'ohne {chars}', placeholders: ['chars'] },
+    'codetable.print_again': { text: 'Nochmal drucken' },
+    'codetable.not_checked': { text: 'Umlaute noch nicht geprüft' },
+    'codetable.check': { text: 'Umlaute prüfen' },
+    'codetable.current': { text: 'Zeichensatz: Nr. {number}', placeholders: ['number'] },
+    // Ueberschrift der Anleitung am Testblatt.
+    'codetable.instruction_title': { text: 'Welche Zeile nehmen?' },
+    // Nach der Wahl: das Beispiel so, wie es mit der Zeile am Bon steht
+    // (`codeTablePreviewText`), dann uebernehmen oder zurueck zur Frage.
+    'codetable.preview_title': { text: 'So steht es dann am Bon:' },
+    'codetable.apply': { text: 'Übernehmen' },
+    'codetable.other_row': { text: 'Andere Zeile' },
 };
 exports.LABELS = BESCHRIFTUNGEN_ROH;
 /** Die Beschriftung zum Schluessel, Platzhalter ersetzt; fehlt ein Wert, wirft es wie `messageText`. */

package/dist/cjs/printing/code-table-preview.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Die Vorschau im Drucker-Wizard: nach der Wahl einer Zeile zeigt der
+ * Bildschirm ein Beispiel so, wie es mit dieser Tabelle am Bon steht. Wer
+ * Zeile 4 (PC437) waehlt, sieht „3,50 EUR“ statt „3,50 €“, bevor er
+ * uebernimmt. Gemeinsamer Prueffall mit dem Dart-Zwilling:
+ * `fixtures/code-table-preview.json`.
+ */
+import { type CodeTableId } from './code-tables.js';
+/**
+ * Das Beispiel mit den Ersetzungen der Tabelle, Zeilen durch `\n` getrennt:
+ * fehlt der Tabelle ein Zeichen, stehen seine Ersatzbuchstaben da
+ * (`pc437` -> „Käsekrainer 3,50 EUR“, `replacement` -> „Kaesekrainer 3,50 EUR“).
+ * Eine unbekannte Kennung wird gemeldet.
+ */
+export declare function codeTablePreviewText(table: CodeTableId): string;

package/dist/cjs/printing/code-table-preview.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.codeTablePreviewText = codeTablePreviewText;
+/**
+ * Die Vorschau im Drucker-Wizard: nach der Wahl einer Zeile zeigt der
+ * Bildschirm ein Beispiel so, wie es mit dieser Tabelle am Bon steht. Wer
+ * Zeile 4 (PC437) waehlt, sieht „3,50 EUR“ statt „3,50 €“, bevor er
+ * uebernimmt. Gemeinsamer Prueffall mit dem Dart-Zwilling:
+ * `fixtures/code-table-preview.json`.
+ */
+const code_tables_js_1 = require("./code-tables.js");
+const printable_js_1 = require("./printable.js");
+/** Das Beispiel: Umlaut, €, °. */
+const BEISPIEL = ['Käsekrainer 3,50 €', 'Tee 80°'];
+/**
+ * Das Beispiel mit den Ersetzungen der Tabelle, Zeilen durch `\n` getrennt:
+ * fehlt der Tabelle ein Zeichen, stehen seine Ersatzbuchstaben da
+ * (`pc437` -> „Käsekrainer 3,50 EUR“, `replacement` -> „Kaesekrainer 3,50 EUR“).
+ * Eine unbekannte Kennung wird gemeldet.
+ */
+function codeTablePreviewText(table) {
+    (0, code_tables_js_1.codeTableById)(table);
+    return BEISPIEL.map((zeile) => (0, printable_js_1.escPosPrintableText)(zeile, table)).join('\n');
+}

package/dist/cjs/printing/code-tables.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Katalog der Code-Tabellen fuer Bondrucker und die Umwandlung von Text in
+ * Bytes je Tabelle.
+ *
+ * Warum ein Katalog: `ESC t n` waehlt die Zeichentabelle, aber die Nummer n
+ * ist nicht einheitlich. Epson legt WPC1252 auf 16, viele guenstige Drucker
+ * nummerieren anders oder kennen die Tabelle gar nicht. Wer am Testblatt
+ * sieht, welche Nummer seine Umlaute richtig druckt, waehlt hier die
+ * passende Tabelle. Gemeinsamer Prueffall mit dem Dart-Zwilling:
+ * `fixtures/code-tables.json`.
+ *
+ * Jede Tabelle setzt die zehn deutschen Zeichen (Umlaute, ß, €, §, °) auf
+ * ein Byte oder, wo die Tabelle das Zeichen nicht hat, auf Ersatzbuchstaben
+ * (`€` -> `EUR`). Fuer diese zehn Zeichen kommt nie `?` heraus.
+ */
+/** Kennung einer Code-Tabelle. */
+export type CodeTableId = 'wpc1252' | 'pc858' | 'pc850' | 'pc437' | 'iso8859_15' | 'replacement';
+/** Eine Code-Tabelle des Katalogs. */
+export interface CodeTable {
+    /** Kennung. */
+    id: CodeTableId;
+    /** Nummer auf dem Testblatt (1-6). */
+    number: 1 | 2 | 3 | 4 | 5 | 6;
+    /** n fuer `ESC t n`. */
+    escT: number;
+    /** Zeichen der zehn, die diese Tabelle nicht hat und durch Ersatzbuchstaben druckt. */
+    missing: readonly string[];
+}
+/**
+ * Ersatzbuchstaben fuer eines der zehn Zeichen (paketintern, fuer
+ * `escPosPrintableText` mit gewaehlter Tabelle).
+ */
+export declare function ersatzBuchstaben(zeichen: string): string;
+/** Alle Code-Tabellen in der Reihenfolge des Testblatts (Nummer 1-6). */
+export declare const CODE_TABLES: readonly CodeTable[];
+/** Die Tabelle zu einer Kennung; eine unbekannte Kennung wird gemeldet. */
+export declare function codeTableById(id: CodeTableId): CodeTable;
+/**
+ * Tabelle aus der gespeicherten Einstellung (`cp1252`/`cp437`). Alles andere,
+ * auch keine Einstellung, ist die Vorgabe `wpc1252`.
+ */
+export declare function codeTableFromSetting(setting: 'cp1252' | 'cp437' | null | undefined): CodeTableId;
+/**
+ * Zeichen, die das Vorbild vor dem Kodieren ersetzt (generator.dart `_encode`).
+ *
+ * **Eine bewusste Abweichung:** Fuer `•` sagt generator.dart `.`,
+ * print_paper.dart (portiert als `escPosPrintableText`) dagegen `*`. In Darts
+ * eigener Kette faellt das nie auf, weil print_paper vor dem Erzeuger ersetzt
+ * und der Erzeuger den Punkt nie zu sehen bekommt -- die gedruckte Antwort ist
+ * dort also `*`. Ein Verbraucher dieses Pakets kann `escPosText` aber auch
+ * direkt aufrufen, und dann duerfen nicht zwei Zeichen fuer dasselbe Zeichen
+ * herauskommen. Deshalb gilt hier dieselbe Antwort wie dort.
+ */
+export declare const ZEICHEN_ERSATZ: ReadonlyArray<readonly [string, string]>;
+/**
+ * Latin-1-Byte -> CP437-Byte fuer die Zeichen, die CP437 kennt (deutsche
+ * Umlaute, ß, westeuropaeische Akzente, Waehrungs-/Sonderzeichen). Alles
+ * andere ab 0x80 hat in CP437 keinen Platz und wird zu "?".
+ */
+export declare const CP437_AUS_LATIN1: ReadonlyMap<number, number>;
+/**
+ * Wandelt Text in die Bytes einer Code-Tabelle: erst die vorhandenen
+ * Ersetzungen (`ZEICHEN_ERSATZ`), dann die zehn deutschen Zeichen je Tabelle
+ * (Byte oder Ersatzbuchstaben), ASCII unveraendert, alles uebrige ueber die
+ * Abbildung der Tabelle, sonst `?`. Ein Zeichen, das die Tabelle nicht
+ * kennt, ist genau ein Byte; nur die Ersatzbuchstaben machen aus einem
+ * Zeichen mehrere. Spalten darum immer an den fertigen Bytes messen.
+ */
+export declare function encodeForCodeTable(text: string, table: CodeTableId): Uint8Array;
+/** Wendet `ZEICHEN_ERSATZ` an (paketintern, nicht exportiert ueber den Einstieg). */
+export declare function replaceKnownCharacters(text: string): string;
+/**
+ * Wie `encodeForCodeTable`, aber fuer Text, der `ZEICHEN_ERSATZ` schon hinter
+ * sich hat (paketintern: der alte Pfad in `encodeEscPosText` ersetzt vor der
+ * Latin-1-Pruefung und soll nicht zweimal ersetzen).
+ */
+export declare function encodeReplaced(aufbereitet: string, table: CodeTableId): Uint8Array;

package/dist/cjs/printing/code-tables.js

@@ -0,0 +1,224 @@
+"use strict";
+/**
+ * Katalog der Code-Tabellen fuer Bondrucker und die Umwandlung von Text in
+ * Bytes je Tabelle.
+ *
+ * Warum ein Katalog: `ESC t n` waehlt die Zeichentabelle, aber die Nummer n
+ * ist nicht einheitlich. Epson legt WPC1252 auf 16, viele guenstige Drucker
+ * nummerieren anders oder kennen die Tabelle gar nicht. Wer am Testblatt
+ * sieht, welche Nummer seine Umlaute richtig druckt, waehlt hier die
+ * passende Tabelle. Gemeinsamer Prueffall mit dem Dart-Zwilling:
+ * `fixtures/code-tables.json`.
+ *
+ * Jede Tabelle setzt die zehn deutschen Zeichen (Umlaute, ß, €, §, °) auf
+ * ein Byte oder, wo die Tabelle das Zeichen nicht hat, auf Ersatzbuchstaben
+ * (`€` -> `EUR`). Fuer diese zehn Zeichen kommt nie `?` heraus.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CP437_AUS_LATIN1 = exports.ZEICHEN_ERSATZ = exports.CODE_TABLES = void 0;
+exports.ersatzBuchstaben = ersatzBuchstaben;
+exports.codeTableById = codeTableById;
+exports.codeTableFromSetting = codeTableFromSetting;
+exports.encodeForCodeTable = encodeForCodeTable;
+exports.replaceKnownCharacters = replaceKnownCharacters;
+exports.encodeReplaced = encodeReplaced;
+/** Die zehn Zeichen, fuer die jede Tabelle eine feste Antwort hat. */
+const ZEHN_ZEICHEN = ['ä', 'ö', 'ü', 'Ä', 'Ö', 'Ü', 'ß', '€', '§', '°'];
+/** Ersatzbuchstaben, wenn die Tabelle das Zeichen nicht hat. */
+const ERSATZ_BUCHSTABEN = {
+    'ä': 'ae', 'ö': 'oe', 'ü': 'ue', 'Ä': 'Ae', 'Ö': 'Oe', 'Ü': 'Ue', 'ß': 'ss', '€': 'EUR', '§': 'Par.', '°': 'Grad',
+};
+/**
+ * Byte je Zeichen und Tabelle; fehlt ein Zeichen, gilt der Ersatz. Werte aus
+ * den Zeichentabellen (Windows-1252, IBM 858/850/437, ISO 8859-15).
+ */
+const BYTES_JE_TABELLE = {
+    wpc1252: { 'ä': 0xe4, 'ö': 0xf6, 'ü': 0xfc, 'Ä': 0xc4, 'Ö': 0xd6, 'Ü': 0xdc, 'ß': 0xdf, '€': 0x80, '§': 0xa7, '°': 0xb0 },
+    pc858: { 'ä': 0x84, 'ö': 0x94, 'ü': 0x81, 'Ä': 0x8e, 'Ö': 0x99, 'Ü': 0x9a, 'ß': 0xe1, '€': 0xd5, '§': 0xf5, '°': 0xf8 },
+    pc850: { 'ä': 0x84, 'ö': 0x94, 'ü': 0x81, 'Ä': 0x8e, 'Ö': 0x99, 'Ü': 0x9a, 'ß': 0xe1, '§': 0xf5, '°': 0xf8 },
+    pc437: { 'ä': 0x84, 'ö': 0x94, 'ü': 0x81, 'Ä': 0x8e, 'Ö': 0x99, 'Ü': 0x9a, 'ß': 0xe1, '°': 0xf8 },
+    iso8859_15: { 'ä': 0xe4, 'ö': 0xf6, 'ü': 0xfc, 'Ä': 0xc4, 'Ö': 0xd6, 'Ü': 0xdc, 'ß': 0xdf, '€': 0xa4, '§': 0xa7, '°': 0xb0 },
+    replacement: {},
+};
+/**
+ * Ersatzbuchstaben fuer eines der zehn Zeichen (paketintern, fuer
+ * `escPosPrintableText` mit gewaehlter Tabelle).
+ */
+function ersatzBuchstaben(zeichen) {
+    const ersatz = ERSATZ_BUCHSTABEN[zeichen];
+    if (ersatz === undefined)
+        throw new Error(`Kein Ersatz fuer ${zeichen}`);
+    return ersatz;
+}
+function tabelle(id, number, escT) {
+    const bytes = BYTES_JE_TABELLE[id];
+    return Object.freeze({ id, number, escT, missing: Object.freeze(ZEHN_ZEICHEN.filter((z) => bytes[z] === undefined)) });
+}
+/** Alle Code-Tabellen in der Reihenfolge des Testblatts (Nummer 1-6). */
+exports.CODE_TABLES = Object.freeze([
+    tabelle('wpc1252', 1, 16),
+    tabelle('pc858', 2, 19),
+    tabelle('pc850', 3, 2),
+    tabelle('pc437', 4, 0),
+    tabelle('iso8859_15', 5, 40),
+    tabelle('replacement', 6, 0),
+]);
+/** Die Tabelle zu einer Kennung; eine unbekannte Kennung wird gemeldet. */
+function codeTableById(id) {
+    const gefunden = exports.CODE_TABLES.find((t) => t.id === id);
+    if (gefunden === undefined)
+        throw new Error(`Unbekannte Code-Tabelle: ${String(id)}`);
+    return gefunden;
+}
+/**
+ * Tabelle aus der gespeicherten Einstellung (`cp1252`/`cp437`). Alles andere,
+ * auch keine Einstellung, ist die Vorgabe `wpc1252`.
+ */
+function codeTableFromSetting(setting) {
+    return setting === 'cp437' ? 'pc437' : 'wpc1252';
+}
+/**
+ * Zeichen, die das Vorbild vor dem Kodieren ersetzt (generator.dart `_encode`).
+ *
+ * **Eine bewusste Abweichung:** Fuer `•` sagt generator.dart `.`,
+ * print_paper.dart (portiert als `escPosPrintableText`) dagegen `*`. In Darts
+ * eigener Kette faellt das nie auf, weil print_paper vor dem Erzeuger ersetzt
+ * und der Erzeuger den Punkt nie zu sehen bekommt -- die gedruckte Antwort ist
+ * dort also `*`. Ein Verbraucher dieses Pakets kann `escPosText` aber auch
+ * direkt aufrufen, und dann duerfen nicht zwei Zeichen fuer dasselbe Zeichen
+ * herauskommen. Deshalb gilt hier dieselbe Antwort wie dort.
+ */
+exports.ZEICHEN_ERSATZ = [
+    ['’', "'"], // typografisches Apostroph
+    ['´', "'"], // Akut
+    ['•', '*'], // Aufzaehlungspunkt (siehe Kommentar oben)
+];
+/**
+ * Latin-1-Byte -> CP437-Byte fuer die Zeichen, die CP437 kennt (deutsche
+ * Umlaute, ß, westeuropaeische Akzente, Waehrungs-/Sonderzeichen). Alles
+ * andere ab 0x80 hat in CP437 keinen Platz und wird zu "?".
+ */
+exports.CP437_AUS_LATIN1 = new Map([
+    [0xc7, 0x80], [0xfc, 0x81], [0xe9, 0x82], [0xe2, 0x83], [0xe4, 0x84], [0xe0, 0x85], [0xe5, 0x86], [0xe7, 0x87],
+    [0xea, 0x88], [0xeb, 0x89], [0xe8, 0x8a], [0xef, 0x8b], [0xee, 0x8c], [0xec, 0x8d], [0xc4, 0x8e], [0xc5, 0x8f],
+    [0xc9, 0x90], [0xe6, 0x91], [0xc6, 0x92], [0xf4, 0x93], [0xf6, 0x94], [0xf2, 0x95], [0xfb, 0x96], [0xf9, 0x97],
+    [0xff, 0x98], [0xd6, 0x99], [0xdc, 0x9a], [0xa2, 0x9b], [0xa3, 0x9c], [0xa5, 0x9d], [0xe1, 0xa0], [0xed, 0xa1],
+    [0xf3, 0xa2], [0xfa, 0xa3], [0xf1, 0xa4], [0xd1, 0xa5], [0xaa, 0xa6], [0xba, 0xa7], [0xbf, 0xa8], [0xac, 0xaa],
+    [0xbd, 0xab], [0xbc, 0xac], [0xa1, 0xad], [0xab, 0xae], [0xbb, 0xaf], [0xdf, 0xe1], [0xb5, 0xe6], [0xb1, 0xf1],
+    [0xf7, 0xf6], [0xb0, 0xf8], [0xb7, 0xfa], [0xb2, 0xfd], [0xa0, 0xff],
+]);
+/**
+ * Latin-1-Byte -> PC850-Byte (IBM 850, gleich fuer 858 bis auf das €, das
+ * die zehn Zeichen oben schon setzen). PC850 hat fuer jedes Latin-1-Zeichen
+ * ab 0xA0 einen Platz; die Steuerzeichen 0x80-0x9F werden zu "?".
+ */
+const PC850_AUS_LATIN1 = new Map([
+    [0xa0, 0xff], [0xa1, 0xad], [0xa2, 0xbd], [0xa3, 0x9c], [0xa4, 0xcf], [0xa5, 0xbe], [0xa6, 0xdd], [0xa7, 0xf5],
+    [0xa8, 0xf9], [0xa9, 0xb8], [0xaa, 0xa6], [0xab, 0xae], [0xac, 0xaa], [0xad, 0xf0], [0xae, 0xa9], [0xaf, 0xee],
+    [0xb0, 0xf8], [0xb1, 0xf1], [0xb2, 0xfd], [0xb3, 0xfc], [0xb4, 0xef], [0xb5, 0xe6], [0xb6, 0xf4], [0xb7, 0xfa],
+    [0xb8, 0xf7], [0xb9, 0xfb], [0xba, 0xa7], [0xbb, 0xaf], [0xbc, 0xac], [0xbd, 0xab], [0xbe, 0xf3], [0xbf, 0xa8],
+    [0xc0, 0xb7], [0xc1, 0xb5], [0xc2, 0xb6], [0xc3, 0xc7], [0xc4, 0x8e], [0xc5, 0x8f], [0xc6, 0x92], [0xc7, 0x80],
+    [0xc8, 0xd4], [0xc9, 0x90], [0xca, 0xd2], [0xcb, 0xd3], [0xcc, 0xde], [0xcd, 0xd6], [0xce, 0xd7], [0xcf, 0xd8],
+    [0xd0, 0xd1], [0xd1, 0xa5], [0xd2, 0xe3], [0xd3, 0xe0], [0xd4, 0xe2], [0xd5, 0xe5], [0xd6, 0x99], [0xd7, 0x9e],
+    [0xd8, 0x9d], [0xd9, 0xeb], [0xda, 0xe9], [0xdb, 0xea], [0xdc, 0x9a], [0xdd, 0xed], [0xde, 0xe8], [0xdf, 0xe1],
+    [0xe0, 0x85], [0xe1, 0xa0], [0xe2, 0x83], [0xe3, 0xc6], [0xe4, 0x84], [0xe5, 0x86], [0xe6, 0x91], [0xe7, 0x87],
+    [0xe8, 0x8a], [0xe9, 0x82], [0xea, 0x88], [0xeb, 0x89], [0xec, 0x8d], [0xed, 0xa1], [0xee, 0x8c], [0xef, 0x8b],
+    [0xf0, 0xd0], [0xf1, 0xa4], [0xf2, 0x95], [0xf3, 0xa2], [0xf4, 0x93], [0xf5, 0xe4], [0xf6, 0x94], [0xf7, 0xf6],
+    [0xf8, 0x9b], [0xf9, 0x97], [0xfa, 0xa3], [0xfb, 0x96], [0xfc, 0x81], [0xfd, 0xec], [0xfe, 0xe7], [0xff, 0x98],
+]);
+const FRAGEZEICHEN = 0x3f;
+/**
+ * Windows-1252 belegt 0x80-0x9F mit eigenen Zeichen (Latin-1 hat dort nur
+ * Steuerzeichen). € setzen die zehn Zeichen, ’ und • ersetzt ZEICHEN_ERSATZ
+ * vorher (eine Antwort auf jedem Ausgabeweg); der Rest steht hier.
+ */
+const WPC1252_NEU = new Map([
+    [0x201a, 0x82], [0x0192, 0x83], [0x201e, 0x84], [0x2026, 0x85], [0x2020, 0x86], [0x2021, 0x87], [0x02c6, 0x88],
+    [0x2030, 0x89], [0x0160, 0x8a], [0x2039, 0x8b], [0x0152, 0x8c], [0x017d, 0x8e], [0x2018, 0x91], [0x2019, 0x92],
+    [0x201c, 0x93], [0x201d, 0x94], [0x2022, 0x95], [0x2013, 0x96], [0x2014, 0x97], [0x02dc, 0x98], [0x2122, 0x99],
+    [0x0161, 0x9a], [0x203a, 0x9b], [0x0153, 0x9c], [0x017e, 0x9e], [0x0178, 0x9f],
+]);
+/**
+ * ISO 8859-15 belegt acht Stellen anders als Latin-1: dort stehen € Š š Ž ž
+ * Œ œ Ÿ statt ¤ ¦ ¨ ´ ¸ ¼ ½ ¾. Die acht Latin-1-Zeichen fehlen der Tabelle
+ * (Ersetzung, sonst `?`), die neuen stehen hier mit ihrem Byte (€ setzen
+ * schon die zehn Zeichen). C1-Steuerzeichen (0x80-0x9F) gehen nie roh hinaus.
+ */
+const ISO8859_15_ANDERS = new Set([0xa4, 0xa6, 0xa8, 0xb4, 0xb8, 0xbc, 0xbd, 0xbe]);
+const ISO8859_15_NEU = new Map([
+    [0x0160, 0xa6], [0x0161, 0xa8], [0x017d, 0xb4], [0x017e, 0xb8], [0x0152, 0xbc], [0x0153, 0xbd], [0x0178, 0xbe],
+]);
+/** Byte fuer ein Zeichen ab 0x80, das nicht zu den zehn gehoert. */
+function uebrigesZeichen(codepunkt, id) {
+    switch (id) {
+        case 'wpc1252':
+            if (codepunkt < 0xa0)
+                return FRAGEZEICHEN; // C1-Steuerzeichen
+            if (codepunkt <= 0xff)
+                return codepunkt;
+            return WPC1252_NEU.get(codepunkt) ?? FRAGEZEICHEN;
+        case 'iso8859_15':
+            if (codepunkt < 0xa0)
+                return FRAGEZEICHEN; // C1-Steuerzeichen
+            if (codepunkt <= 0xff)
+                return ISO8859_15_ANDERS.has(codepunkt) ? FRAGEZEICHEN : codepunkt;
+            return ISO8859_15_NEU.get(codepunkt) ?? FRAGEZEICHEN;
+        case 'pc437':
+            return exports.CP437_AUS_LATIN1.get(codepunkt) ?? FRAGEZEICHEN;
+        case 'pc858':
+        case 'pc850':
+            return PC850_AUS_LATIN1.get(codepunkt) ?? FRAGEZEICHEN;
+        case 'replacement':
+            return FRAGEZEICHEN;
+    }
+}
+/**
+ * Wandelt Text in die Bytes einer Code-Tabelle: erst die vorhandenen
+ * Ersetzungen (`ZEICHEN_ERSATZ`), dann die zehn deutschen Zeichen je Tabelle
+ * (Byte oder Ersatzbuchstaben), ASCII unveraendert, alles uebrige ueber die
+ * Abbildung der Tabelle, sonst `?`. Ein Zeichen, das die Tabelle nicht
+ * kennt, ist genau ein Byte; nur die Ersatzbuchstaben machen aus einem
+ * Zeichen mehrere. Spalten darum immer an den fertigen Bytes messen.
+ */
+function encodeForCodeTable(text, table) {
+    return encodeReplaced(replaceKnownCharacters(text), table);
+}
+/** Wendet `ZEICHEN_ERSATZ` an (paketintern, nicht exportiert ueber den Einstieg). */
+function replaceKnownCharacters(text) {
+    let aufbereitet = text;
+    for (const [von, nach] of exports.ZEICHEN_ERSATZ) {
+        aufbereitet = aufbereitet.split(von).join(nach);
+    }
+    return aufbereitet;
+}
+/**
+ * Wie `encodeForCodeTable`, aber fuer Text, der `ZEICHEN_ERSATZ` schon hinter
+ * sich hat (paketintern: der alte Pfad in `encodeEscPosText` ersetzt vor der
+ * Latin-1-Pruefung und soll nicht zweimal ersetzen).
+ */
+function encodeReplaced(aufbereitet, table) {
+    const bytesDerTabelle = BYTES_JE_TABELLE[table];
+    if (bytesDerTabelle === undefined)
+        throw new Error(`Unbekannte Code-Tabelle: ${String(table)}`);
+    const bytes = [];
+    for (const zeichen of aufbereitet) {
+        const codepunkt = zeichen.codePointAt(0);
+        if (codepunkt < 0x80) {
+            bytes.push(codepunkt);
+            continue;
+        }
+        const byte = bytesDerTabelle[zeichen];
+        if (byte !== undefined) {
+            bytes.push(byte);
+            continue;
+        }
+        const ersatz = ERSATZ_BUCHSTABEN[zeichen];
+        if (ersatz !== undefined) {
+            for (let i = 0; i < ersatz.length; i++)
+                bytes.push(ersatz.charCodeAt(i));
+            continue;
+        }
+        bytes.push(uebrigesZeichen(codepunkt, table));
+    }
+    return Uint8Array.from(bytes);
+}

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

@@ -23,11 +23,14 @@
  * `ESC t 16` und bleiben in CP437; dann werden die Umlaute auf ihre
  * CP437-Plaetze umkodiert (ä = 0x84, ü = 0x81, ß = 0xE1, ...). Zeichen ohne
  * CP437-Platz werden zu `?` — weiterhin ein Byte je Zeichen.
+ * Weitere Tabellen (PC858, PC850, ISO 8859-15, reine Ersatzbuchstaben) und
+ * ihre `ESC t`-Nummern stehen im Katalog `code-tables.ts`.
  *
  * Nicht enthalten (bewusst): Bilddekodierung (PNG/JPEG liest die Huelle),
  * Capability-Profile einzelner Druckermodelle, Kassenlade, 1D-Barcodes.
  * Fertige einfarbige Rasterbilder (Logo) gehen ueber [escPosRasterImage].
  */
+import { type CodeTableId } from './code-tables.js';
 import { type QrModuleSize } from './qr-groesse.js';
 /** Papierbreite der Bonrolle. */
 export type PosPaperSize = 'mm58' | 'mm80';
@@ -37,8 +40,12 @@ export type PosAlign = 'left' | 'center' | 'right';
 export type PosFont = 'fontA' | 'fontB';
 /** Voller oder teilweiser Papierschnitt. */
 export type PosCutMode = 'full' | 'partial';
-/** Vom Drucker zu verwendende Codepage. */
-export type PosCodeTable = 'CP437' | 'CP1252';
+/**
+ * Vom Drucker zu verwendende Codepage: eine Tabelle des Katalogs
+ * (`CODE_TABLES`) oder einer der alten Namen. `CP1252` entspricht `wpc1252`,
+ * `CP437` entspricht `pc437`.
+ */
+export type PosCodeTable = 'CP437' | 'CP1252' | CodeTableId;
 /** Zeichenvergroesserung (1 = einfach, 2 = doppelt, ... bis 8). */
 export type PosTextSize = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8;
 /** Modulgroesse des QR-Codes (Punkte je Modul). */
@@ -171,10 +178,16 @@ export interface EscPosDocument {
     styles: AktuelleStile;
 }
 /**
- * Kodiert Text so, wie ihn der Drucker erwartet: ein Byte je Zeichen nach
- * Latin-1, vorher die vier Zeichenersetzungen des Vorbilds. Ein Umlaut wird
- * damit zu genau einem Byte — Voraussetzung dafuer, dass die Spaltenrechnung
- * stimmt.
+ * Kodiert Text so, wie ihn der Drucker erwartet: ein Byte je Zeichen in der
+ * gewaehlten Tabelle (`encodeForCodeTable`). Ein Umlaut wird damit zu genau
+ * einem Byte -- Voraussetzung dafuer, dass die Spaltenrechnung stimmt.
+ *
+ * Die alten Namen `CP1252` und `CP437` bleiben streng: ein Zeichen ausserhalb
+ * Latin-1 wird gemeldet statt verstuemmelt (vorher `escPosPrintableText`
+ * anwenden). `CP1252` gibt Latin-1 byte-gleich wie bisher aus (auch ein
+ * C1-Steuerzeichen roh, das `wpc1252` zu `?` macht); `CP437` hat die Bytes
+ * von `pc437`. Die Tabellen des Katalogs wandeln dagegen jedes Zeichen um
+ * (Ersatzbuchstaben, sonst `?`).
  */
 export declare function encodeEscPosText(text: string, codeTable?: PosCodeTable): Uint8Array;
 /** Zeichen je Zeile fuer Papier und Schrift (`fontA`, wenn nichts gesetzt ist). */