@kreiseck/kasseneck-api 1.0.0 → 1.1.1

package/dist/esm/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/esm/pos/texte.js

@@ -245,6 +245,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'] },
@@ -556,6 +568,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' },
 };
 export const LABELS = BESCHRIFTUNGEN_ROH;
 /** Die Beschriftung zum Schluessel, Platzhalter ersetzt; fehlt ein Wert, wirft es wie `messageText`. */

package/dist/esm/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/esm/printing/code-table-preview.js

@@ -0,0 +1,21 @@
+/**
+ * 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 { codeTableById } from './code-tables.js';
+import { escPosPrintableText } from './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.
+ */
+export function codeTablePreviewText(table) {
+    codeTableById(table);
+    return BEISPIEL.map((zeile) => escPosPrintableText(zeile, table)).join('\n');
+}

package/dist/esm/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/esm/printing/code-tables.js

@@ -0,0 +1,215 @@
+/**
+ * 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.
+ */
+/** 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).
+ */
+export 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). */
+export const 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. */
+export function codeTableById(id) {
+    const gefunden = 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`.
+ */
+export 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.
+ */
+export const 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 "?".
+ */
+export const 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 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.
+ */
+export function encodeForCodeTable(text, table) {
+    return encodeReplaced(replaceKnownCharacters(text), table);
+}
+/** Wendet `ZEICHEN_ERSATZ` an (paketintern, nicht exportiert ueber den Einstieg). */
+export function replaceKnownCharacters(text) {
+    let aufbereitet = text;
+    for (const [von, nach] of 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).
+ */
+export 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/esm/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). */

package/dist/esm/printing/escpos.js

@@ -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 { CODE_TABLES, encodeForCodeTable, encodeReplaced, replaceKnownCharacters, } from './code-tables.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
@@ -61,8 +64,15 @@ const C_POS = [ESC, 0x24]; // ESC $ nL nH
 const C_FEED_N = [ESC, 0x64]; // ESC d n
 const C_QR_HEADER = [GS, 0x28, 0x6b]; // GS ( k
 const ZEILENUMBRUCH = 0x0a;
-/** Codepage-Nummern fuer `ESC t n` — aus capability_profile.dart. */
-const CODEPAGE_ID = { CP437: 0, CP1252: 16 };
+/**
+ * Codepage-Nummern fuer `ESC t n`: die alten Namen aus capability_profile.dart
+ * (CP437 = 0, CP1252 = 16), dazu jede Tabelle des Katalogs.
+ */
+const CODEPAGE_ID = {
+    CP437: 0,
+    CP1252: 16,
+    ...Object.fromEntries(CODE_TABLES.map((t) => [t.id, t.escT])),
+};
 /** Korrekturstufen fuer GS ( k Funktion 169 — aus qrcode.dart. */
 const QR_KORREKTUR = { L: 48, M: 49, Q: 50, H: 51 };
 /** Nennbreite der Rolle in Millimetern — nur fuer Meldungstexte. */
@@ -82,22 +92,6 @@ const ZEICHEN_JE_ZEILE = {
     mm58: { fontA: 32, fontB: 42 },
     mm80: { fontA: 48, fontB: 64 },
 };
-/**
- * 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.
- */
-const ZEICHEN_ERSATZ = [
-    ['’', "'"], // typografisches Apostroph
-    ['´', "'"], // Akut
-    ['•', '*'], // Aufzaehlungspunkt (siehe Kommentar oben)
-];
 // ------------------------------------------------------------------ Helfer
 function anhaengen(doc, bytes) {
     const ziel = doc.bytes;
@@ -128,40 +122,25 @@ function latin1(text) {
     return bytes;
 }
 /**
- * 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 function encodeEscPosText(text, codeTable = 'CP1252') {
-    let aufbereitet = text;
-    for (const [von, nach] of ZEICHEN_ERSATZ) {
-        aufbereitet = aufbereitet.split(von).join(nach);
-    }
-    const bytes = latin1(aufbereitet);
-    if (codeTable !== 'CP437')
-        return bytes;
-    for (let i = 0; i < bytes.length; i++) {
-        const b = bytes[i] ?? 0;
-        if (b >= 0x80)
-            bytes[i] = CP437_AUS_LATIN1.get(b) ?? 0x3f;
+    if (codeTable === 'CP1252' || codeTable === 'CP437') {
+        const aufbereitet = replaceKnownCharacters(text);
+        const bytes = latin1(aufbereitet); // wirft ausserhalb Latin-1
+        return codeTable === 'CP1252' ? bytes : encodeReplaced(aufbereitet, 'pc437');
     }
-    return bytes;
+    return encodeForCodeTable(text, codeTable);
 }
-/**
- * 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 "?".
- */
-const 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],
-]);
 /** Zeichen je Zeile fuer Papier und Schrift (`fontA`, wenn nichts gesetzt ist). */
 export function escPosMaxCharsPerLine(paperSize, font) {
     const breiten = ZEICHEN_JE_ZEILE[paperSize];

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

@@ -1,4 +1,6 @@
 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 CodeTableId, type CodeTable, CODE_TABLES, codeTableById, codeTableFromSetting, encodeForCodeTable, } from './code-tables.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 { codeTablePreviewText } from './code-table-preview.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,6 @@
 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 { CODE_TABLES, codeTableById, codeTableFromSetting, encodeForCodeTable, } from './code-tables.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 { codeTablePreviewText } from './code-table-preview.js';
 export { USB_VENDOR_EPSON, USB_CLASS_PRINTER, UsbTimeoutError, usbDeviceKey, usbFindPrinterEndpoint, usbWriteAll, usbConnectPrinter, usbPrint, usbDisconnect, } from './webusb.js';

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

@@ -15,6 +15,7 @@
  * ersatzlos weg, alles Uebrige auf `?`. Ein Artikelname aus einer
  * ERP-Uebernahme mit Gedankenstrich soll den Beleg nicht verhindern.
  */
+import type { PosCodeTable } from './escpos.js';
 /**
  * Ersetzt alles, was der Bondrucker nicht darstellen kann, durch eine
  * druckbare Entsprechung. Reine Funktion, ohne Zustand und ohne Drucker.
@@ -22,6 +23,17 @@
  * 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 declare function escPosPrintableText(text: string): string;
+export declare function escPosPrintableText(text: string, codeTable?: PosCodeTable | null): string;