@kreiseck/kasseneck-api 1.0.0-rc.4 → 1.0.0

package/dist/esm/pos/texte.js

@@ -20,11 +20,24 @@
  * `only`), die Platzhalter und die Arten der Fehlerregeln (Abschnitte
  * `placeholders` und `structure`).
  */
+import { isOutcomeUnknown, KasseneckApiError, KasseneckHttpError, KasseneckNetworkError } from '../client/errors.js';
 const MELDUNGEN_ROH = {
     // --- Transport -----------------------------------------------------------
     'network.no_connection': { text: 'Keine Verbindung zum Server. Bitte die Internetverbindung prüfen und erneut versuchen.' },
     'network.timeout': { text: 'Der Server antwortet nicht. Bitte die Internetverbindung prüfen und erneut versuchen.' },
+    // Frist oder Netzfehler auf einem Aufruf mit Wirkung (ERROR_OUTCOME_RULES):
+    // der Vorgang kann trotzdem gebucht sein, darum nie „erneut versuchen“.
+    'network.outcome_unknown': { text: 'Der Server hat nicht geantwortet, der Vorgang kann trotzdem gebucht sein. Bitte vor einem neuen Versuch prüfen, ob der letzte Vorgang schon gebucht ist.' },
     'server.unexpected': { text: 'Der Server hat unerwartet geantwortet (HTTP {status}). Bitte den Support verständigen.', placeholders: ['status'] },
+    // Rand-Codes, die ein Kassier nicht deuten kann (siehe ERROR_CODE_RULES): der
+    // technische Satz bleibt in `error.message`, auf den Schirm kommt dieser.
+    // Nur fuer Codes, bei denen der Server nichts ausgefuehrt hat: dann darf
+    // der Satz zum neuen Versuch raten.
+    'server.connection_disturbed': { text: 'Die Verbindung zum Kassenserver ist gestört. Bitte kurz warten und erneut versuchen.' },
+    // Codes mit unklarem Ausgang (der Vorgang kann gebucht sein): nie zum
+    // Wiederholen raten, erst nachsehen. „Kasse neu öffnen“ passt fuer beide
+    // Seiten (Web: neu laden, App: neu starten).
+    'server.response_unreadable': { text: 'Die Antwort des Kassenservers war nicht lesbar. Bitte die Kasse neu öffnen und vor einem neuen Versuch prüfen, ob der letzte Vorgang schon gebucht ist.' },
     // --- Kopplung ------------------------------------------------------------
     'pairing.code_missing': { text: 'Bitte den Kopplungs-Code eingeben.' },
     'pairing.failed': { text: 'Die Kopplung ist fehlgeschlagen. Bitte erneut versuchen.' },
@@ -263,8 +276,8 @@ const MELDUNGEN_ROH = {
 export const MESSAGES = MELDUNGEN_ROH;
 /**
  * In welcher Reihenfolge ein Fehler eingeordnet wird, auf beiden Seiten
- * dieselbe. Jede Regel nennt ihre Art (`kind`) und entweder ein Verhalten
- * (`behavior`) oder den Schluessel des Satzes (`key`). Die Arten:
+ * dieselbe. Genau eine Regel je Art (`kind`), mit einem Verhalten
+ * (`behavior`) oder dem Schluessel des Satzes (`key`). Die Arten:
  *   api        - HTTP 200, `status:'error'`: der Satz des Backends, woertlich
  *                (`server_text`)
  *   plain_text - schon fuer den Bildschirm geschrieben: sein eigener Text
@@ -277,6 +290,11 @@ export const MESSAGES = MELDUNGEN_ROH;
  *                (`fallback`)
  * Unter 0.x hiessen sie `klartext`, `zeitablauf`, `netz`, `unerwartet`,
  * `sonst` (Tabelle in `fixtures/renames-1.0.json`).
+ *
+ * Seit 1.0.0-rc.5 verfeinern [ERROR_CODE_RULES] und [ERROR_OUTCOME_RULES]
+ * diese Liste; sie stehen bewusst getrennt, damit ein Leser, der nur nach
+ * `kind` sucht, weiter genau den Satz von rc.4 zeigt. [findErrorRule] wendet
+ * alle drei in der richtigen Reihenfolge an.
  */
 export const ERROR_RULES = [
     { kind: 'api', behavior: 'server_text' },
@@ -286,6 +304,87 @@ export const ERROR_RULES = [
     { kind: 'unexpected', key: 'server.unexpected' },
     { kind: 'other', behavior: 'fallback' },
 ];
+/**
+ * Regeln je Code (`error.code`), vor der Regel der Art: sie ersetzen den
+ * technischen Satz des Pakets bzw. des Rands durch einen Menschentext. Der
+ * technische Satz bleibt in `error.message` fuers Protokoll.
+ *   - `dialect_mismatch`, `response_translation_failed`, `response_unreadable`:
+ *     Ausgang unklar, der Vorgang kann gebucht sein; der Satz raet nie zum
+ *     Wiederholen, sondern zum Nachsehen.
+ *   - `route_missing`, `not_found`, `internal_translation_error`: am Server
+ *     geschah nichts, ein neuer Versuch ist sicher (auch auf den Geldwegen:
+ *     alle drei stehen in `PAYMENT_CALL_REJECTED_CODES`).
+ */
+export const ERROR_CODE_RULES = [
+    { kind: 'api', codes: ['dialect_mismatch', 'response_translation_failed', 'response_unreadable'], key: 'server.response_unreadable' },
+    { kind: 'api', codes: ['route_missing', 'not_found', 'internal_translation_error'], key: 'server.connection_disturbed' },
+];
+/**
+ * Regeln je Ausgang, nach den Code-Regeln und vor der Regel der Art: eine
+ * Frist oder ein Netzfehler auf einem Aufruf mit Wirkung (Ausgang unklar,
+ * siehe [messageOutcome]) raet nie zum Wiederholen. Ein Netzfehler auf einem
+ * Aufruf ohne Wirkung behaelt den Satz von rc.4 („erneut versuchen“).
+ */
+export const ERROR_OUTCOME_RULES = [
+    { kind: 'timeout', outcome: 'unknown', key: 'network.outcome_unknown' },
+    { kind: 'network', outcome: 'unknown', key: 'network.outcome_unknown' },
+];
+/**
+ * Die Regel fuer einen Fehler: zuerst eine Code-Regel mit passender Art und
+ * passendem `code`, dann eine Ausgangs-Regel mit passender Art und
+ * passendem `outcome`, sonst die Regel der Art aus [ERROR_RULES]. Beide
+ * Kassen ordnen so ein.
+ */
+export function findErrorRule(kind, detail = {}) {
+    const { code, outcome } = detail;
+    if (code !== undefined && code !== null) {
+        const treffer = ERROR_CODE_RULES.find((r) => r.kind === kind && r.codes.includes(code));
+        if (treffer)
+            return treffer;
+    }
+    if (outcome !== undefined && outcome !== null) {
+        const treffer = ERROR_OUTCOME_RULES.find((r) => r.kind === kind && r.outcome === outcome);
+        if (treffer)
+            return treffer;
+    }
+    // Jede Art hat genau eine Regel; hierher kommt nur eine fremde Art nicht.
+    return ERROR_RULES.find((r) => r.kind === kind) ?? ERROR_RULES[ERROR_RULES.length - 1];
+}
+/**
+ * Kassen-Aufrufe mit Wirkung, die sich nach einem Netzfehler nicht gefahrlos
+ * wiederholen lassen: die sechs, deren Ausgang das Paket selbst als unklar
+ * fuehrt (Beleg, auch Null- und Startbeleg ueber `createReceipt`, Storno,
+ * FinanzOnline, die drei Geldwege), dazu der Druckjob (zweiter Bon) und die
+ * Belegmail (zweite Mail). Ob die Anfrage vor dem Abriss schon draussen war,
+ * sieht das Paket nicht (fetch wirft in beiden Faellen gleich); darum gilt
+ * hier immer der vorsichtige Satz.
+ */
+export const CALLS_WITH_EFFECT = Object.freeze([
+    'createReceipt',
+    'cancelReceipt',
+    'financeWebService',
+    'hobexPayApi',
+    'hobexRefundApi',
+    'stripeCaptureIntent',
+    'createPrintJob',
+    'sendReceiptEmail',
+]);
+const MIT_WIRKUNG = new Set(CALLS_WITH_EFFECT);
+/**
+ * Der Ausgang, nach dem der Satz gewaehlt wird: `'unknown'`, wenn das Paket
+ * ihn als unklar fuehrt ([isOutcomeUnknown]) oder wenn eine Frist bzw. ein
+ * Netzfehler einen Aufruf aus [CALLS_WITH_EFFECT] traf; sonst der Ausgang
+ * des Fehlers (`'rejected'`) bzw. `undefined` fuer fremde Fehler.
+ */
+export function messageOutcome(error) {
+    if (isOutcomeUnknown(error))
+        return 'unknown';
+    if (error instanceof KasseneckNetworkError)
+        return MIT_WIRKUNG.has(error.functionName.split('/')[0]) ? 'unknown' : error.outcome;
+    if (error instanceof KasseneckApiError || error instanceof KasseneckHttpError)
+        return error.outcome;
+    return undefined;
+}
 /**
  * Beleg per E-Mail senden: welcher `code` des Backends welchen Satz bekommt.
  *
@@ -369,6 +468,10 @@ const BESCHRIFTUNGEN_ROH = {
     'message.dismiss_warning': { text: 'Verstanden – Warnung ausblenden: {message}', placeholders: ['message'] },
     // --- Kopplung und Abmelden -----------------------------------------------
     'pairing.pair_again': { text: 'Neu koppeln' },
+    // Ein Geraet ohne Namen (`deviceLabel: null` unter /v3) in der Auswahl.
+    'register.device_unnamed': { text: 'Kasse' },
+    // Restzeit der PIN-Sperre unter dem Satz des Backends.
+    'login.locked_seconds': { text: 'Noch {seconds} s gesperrt', placeholders: ['seconds'] },
     'logout.question': { text: 'Wirklich abmelden?' },
     'logout.keep_working': { text: 'Weiter arbeiten' },
     'device.unpair': { text: 'Gerät entkoppeln' },
@@ -397,6 +500,9 @@ const BESCHRIFTUNGEN_ROH = {
     'split.payment': { text: 'Zahlung {n}', placeholders: ['n'] },
     'split.amount': { text: 'Betrag' },
     'split.remaining': { text: 'Rest' },
+    // Letzte Runde bei Getrennt zahlen: der Rest samt Rundungscent;
+    // `{cents}` traegt das Vorzeichen (`+1`, `−1`).
+    'split.remaining_with_rounding': { text: 'Rest inkl. Rundung {amount} ({cents} ct)', placeholders: ['amount', 'cents'] },
     'split.divide': { text: '÷ {n}', placeholders: ['n'] },
     'split.tip_basis': { text: '% von diesem Betrag' },
     'split.of_which_tip': { text: 'davon Trinkgeld {amount}', placeholders: ['amount'] },

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

@@ -33,6 +33,10 @@ import type { Voucher } from '../models/voucher.js';
  * rabattiert). Das weiss nur die Kasse; darum ist `tipRecipient` Pflicht,
  * sobald Trinkgeld ohne `recipients` vorkommt. Ohne angemeldeten Benutzer
  * (Geraete-Schluessel) gilt `'staff'`.
+ *
+ * **Nicht rechenbar:** jede unbrauchbare Eingabe wirft [ReceiptDueError]
+ * (`code: 'receipt_due_unavailable'`, `reason` im Einzelnen), nie still eine
+ * falsche Zahl. Dann ist nichts gesendet.
  */
 /** Wer das Trinkgeld ohne `recipients` bekommt (Kennzeichen des angemeldeten Kassen-Benutzers). */
 export type ReceiptDueTipRecipient = 'owner' | 'staff';
@@ -78,6 +82,35 @@ export interface ReceiptDueBreakdown {
     /** Toepfe je auf Cent gerundet; `null` bei Start- und Nullbeleg. */
     bucketsCents: ReceiptDueBuckets | null;
 }
+/**
+ * Warum sich der Zahlbetrag nicht rechnen laesst. Fest wie ein Backend-Code;
+ * dieselbe Liste im Dart-Zwilling und in `fixtures/receipt-due-errors.json`.
+ */
+export declare const RECEIPT_DUE_ERROR_REASONS: readonly ["unknown_receipt_type", "tip_not_allowed", "invalid_item", "invalid_voucher", "invalid_tip", "unknown_payment_method", "tip_conflict", "tip_recipient_missing", "tip_without_goods"];
+export type ReceiptDueErrorReason = (typeof RECEIPT_DUE_ERROR_REASONS)[number];
+/**
+ * Der Zahlbetrag laesst sich aus dieser Eingabe nicht rechnen, etwa
+ * Trinkgeld mit Betrag ohne Ware (`reason: 'tip_without_goods'`).
+ *
+ * Eindeutig **nicht gesendet**: die Rechnung laeuft ganz im Paket, vor jedem
+ * Aufruf. `outcome` ist darum immer `'rejected'`; nichts ist geschehen, keine
+ * Belegnummer verbraucht, keine Karte belastet. Die Kasse sagt das dem
+ * Kassier, bevor sie ein Terminal anspricht. Entscheiden am `code` bzw.
+ * `reason`, nie an `message` (die ist fuers Protokoll).
+ *
+ * Bis 1.0.0-rc.4 warf die Rechnung hier einen `RangeError` ohne Code.
+ */
+export declare class ReceiptDueError extends Error {
+    readonly name = "ReceiptDueError";
+    /** Stabiler Code fuer jede Ursache. */
+    readonly code: "receipt_due_unavailable";
+    /** Die Ursache im Einzelnen. */
+    readonly reason: ReceiptDueErrorReason;
+    /** Immer `'rejected'`: es ging nichts hinaus. */
+    readonly outcome: "rejected";
+    constructor(reason: ReceiptDueErrorReason, message: string);
+}
+export declare function isReceiptDueError(error: unknown): error is ReceiptDueError;
 type BelegArt = ReceiptType | ReceiptTypeKey | string;
 /** Zahlbetrag in Cent, siehe Modulkommentar. */
 export declare function receiptDueCents(items: readonly ReceiptItem[], vouchers: readonly Voucher[], receiptType: BelegArt, options?: ReceiptDueOptions): number;

package/dist/esm/receipt/due.js

@@ -1,4 +1,47 @@
 import { ReceiptType, VoucherAction, VoucherType } from '../enums/index.js';
+/**
+ * Warum sich der Zahlbetrag nicht rechnen laesst. Fest wie ein Backend-Code;
+ * dieselbe Liste im Dart-Zwilling und in `fixtures/receipt-due-errors.json`.
+ */
+export const RECEIPT_DUE_ERROR_REASONS = Object.freeze([
+    'unknown_receipt_type',
+    'tip_not_allowed',
+    'invalid_item',
+    'invalid_voucher',
+    'invalid_tip',
+    'unknown_payment_method',
+    'tip_conflict',
+    'tip_recipient_missing',
+    'tip_without_goods',
+]);
+/**
+ * Der Zahlbetrag laesst sich aus dieser Eingabe nicht rechnen, etwa
+ * Trinkgeld mit Betrag ohne Ware (`reason: 'tip_without_goods'`).
+ *
+ * Eindeutig **nicht gesendet**: die Rechnung laeuft ganz im Paket, vor jedem
+ * Aufruf. `outcome` ist darum immer `'rejected'`; nichts ist geschehen, keine
+ * Belegnummer verbraucht, keine Karte belastet. Die Kasse sagt das dem
+ * Kassier, bevor sie ein Terminal anspricht. Entscheiden am `code` bzw.
+ * `reason`, nie an `message` (die ist fuers Protokoll).
+ *
+ * Bis 1.0.0-rc.4 warf die Rechnung hier einen `RangeError` ohne Code.
+ */
+export class ReceiptDueError extends Error {
+    name = 'ReceiptDueError';
+    /** Stabiler Code fuer jede Ursache. */
+    code = 'receipt_due_unavailable';
+    /** Die Ursache im Einzelnen. */
+    reason;
+    /** Immer `'rejected'`: es ging nichts hinaus. */
+    outcome = 'rejected';
+    constructor(reason, message) {
+        super(`Zahlbetrag: ${message}`);
+        this.reason = reason;
+    }
+}
+export function isReceiptDueError(error) {
+    return error instanceof ReceiptDueError;
+}
 const UMSATZ = new Set(['standard', 'cancellation', 'training']);
 const TRINKGELD_ERLAUBT = new Set(['standard', 'training']);
 const ZAHLARTEN = new Set(['cash', 'creditCard', 'online', 'uberApp', 'uberCard', 'uberCash', 'boltApp', 'boltCard', 'boltCash']);
@@ -11,7 +54,7 @@ export function receiptDueBreakdown(items, vouchers, receiptType, options = {})
     const art = belegArt(receiptType);
     const trinkgelder = trinkgeldAuftraege(options);
     if (trinkgelder.length > 0 && !TRINKGELD_ERLAUBT.has(art)) {
-        throw new RangeError(`Zahlbetrag: Trinkgeld gibt es nur bei standard und training, nicht bei "${art}".`);
+        throw new ReceiptDueError('tip_not_allowed', `Trinkgeld gibt es nur bei standard und training, nicht bei "${art}".`);
     }
     if (!UMSATZ.has(art)) {
         return { dueCents: 0, counterDeltaCents: 0, valueVoucherFlowCents: 0, bucketsCents: null };
@@ -41,7 +84,7 @@ export function receiptDueBreakdown(items, vouchers, receiptType, options = {})
 function belegArt(wert) {
     const text = typeof wert === 'object' && wert !== null ? wert.value : wert;
     if (typeof text !== 'string' || !Object.prototype.hasOwnProperty.call(ReceiptType, text)) {
-        throw new RangeError(`Zahlbetrag: unbekannter Belegtyp "${String(text)}".`);
+        throw new ReceiptDueError('unknown_receipt_type', `unbekannter Belegtyp "${String(text)}".`);
     }
     return text;
 }
@@ -53,17 +96,17 @@ function euroToCent(euro) {
 function innen(item, i) {
     const satz = typeof item.vat === 'number' ? item.vat : item.vat?.rate;
     if (typeof satz !== 'number' || !Number.isFinite(satz))
-        throw new RangeError(`Zahlbetrag: Position ${i + 1} ohne Steuersatz.`);
+        throw new ReceiptDueError('invalid_item', `Position ${i + 1} ohne Steuersatz.`);
     if (!Number.isSafeInteger(item.priceCents))
-        throw new RangeError(`Zahlbetrag: Position ${i + 1} hat keinen ganzen Cent-Preis.`);
+        throw new ReceiptDueError('invalid_item', `Position ${i + 1} hat keinen ganzen Cent-Preis.`);
     if (typeof item.quantity !== 'number' || !Number.isFinite(item.quantity))
-        throw new RangeError(`Zahlbetrag: Position ${i + 1} hat keine gueltige Menge.`);
+        throw new ReceiptDueError('invalid_item', `Position ${i + 1} hat keine gueltige Menge.`);
     const tip = item.kind === 'tip' ? (item.recipient?.owner === true ? 'owner' : 'staff') : null;
     return { amount: item.quantity, priceOne: Math.round(item.priceCents) / 100, vat: satz, tip };
 }
 function gutscheinInnen(v, i) {
     if (!Number.isSafeInteger(v.valueCents))
-        throw new RangeError(`Zahlbetrag: Gutschein ${i + 1} hat keinen ganzen Cent-Wert.`);
+        throw new ReceiptDueError('invalid_voucher', `Gutschein ${i + 1} hat keinen ganzen Cent-Wert.`);
     return { action: String(v.action), type: String(v.type), value: Math.round(v.valueCents) / 100 };
 }
 /** Trinkgeld-Auftraege in der Reihenfolge des Servers: `tip`, dann je Zahlart die Summe der `tipCents`. */
@@ -71,7 +114,7 @@ function trinkgeldAuftraege(options) {
     const raus = [];
     const tipCents = (options.payments ?? []).some((z) => z != null && z.tipCents !== undefined);
     if (options.tip != null && tipCents) {
-        throw new RangeError('Zahlbetrag: tip und payments[].tipCents gehen nicht zugleich (tip_conflict).');
+        throw new ReceiptDueError('tip_conflict', 'tip und payments[].tipCents gehen nicht zugleich (tip_conflict).');
     }
     if (options.tip != null) {
         const tip = options.tip;
@@ -80,14 +123,14 @@ function trinkgeldAuftraege(options) {
         const recipients = typeof tip === 'number' ? undefined : tip.recipients;
         if (recipients != null) {
             if (recipients.length === 0)
-                throw new RangeError('Zahlbetrag: recipients darf nicht leer sein.');
+                throw new ReceiptDueError('invalid_tip', 'recipients darf nicht leer sein.');
             for (const r of recipients) {
                 pruefeCent(r.cents, 'Trinkgeld-Anteil');
                 if (typeof r.owner !== 'boolean')
-                    throw new RangeError('Zahlbetrag: recipients[].owner muss true oder false sein.');
+                    throw new ReceiptDueError('invalid_tip', 'recipients[].owner muss true oder false sein.');
             }
             if (recipients.reduce((s, r) => s + r.cents, 0) !== cents) {
-                throw new RangeError('Zahlbetrag: die Anteile des Trinkgelds ergeben nicht den Betrag.');
+                throw new ReceiptDueError('invalid_tip', 'die Anteile des Trinkgelds ergeben nicht den Betrag.');
             }
             raus.push({ empfaenger: recipients.map((r) => ({ cents: r.cents, owner: r.owner })) });
         }
@@ -103,7 +146,7 @@ function trinkgeldAuftraege(options) {
         pruefeCent(z.tipCents, 'tipCents');
         const methode = typeof z.method === 'object' && z.method !== null ? z.method.value : z.method;
         if (typeof methode !== 'string' || !ZAHLARTEN.has(methode))
-            throw new RangeError(`Zahlbetrag: unbekannte Zahlart "${String(methode)}".`);
+            throw new ReceiptDueError('unknown_payment_method', `unbekannte Zahlart "${String(methode)}".`);
         je.set(methode, (je.get(methode) ?? 0) + z.tipCents);
     }
     for (const cents of je.values())
@@ -112,7 +155,7 @@ function trinkgeldAuftraege(options) {
 }
 function pruefeCent(wert, was) {
     if (typeof wert !== 'number' || !Number.isInteger(wert) || wert <= 0) {
-        throw new RangeError(`Zahlbetrag: ${was} muss eine ganze Zahl in Cent > 0 sein.`);
+        throw new ReceiptDueError('invalid_tip', `${was} muss eine ganze Zahl in Cent > 0 sein.`);
     }
 }
 /** `tip-core.buildTipItems`: Personal in den Null-%-Satz, Inhaber anteilig auf die Saetze der Ware. */
@@ -120,13 +163,13 @@ function trinkgeldPositionen(auftrag, positionen, standard) {
     const basis = warenCentsJeSatz(positionen);
     const summe = Object.values(basis).reduce((s, c) => s + c, 0);
     if (summe <= 0)
-        throw new RangeError('Zahlbetrag: Trinkgeld braucht mindestens eine Position mit Betrag.');
+        throw new ReceiptDueError('tip_without_goods', 'Trinkgeld braucht mindestens eine Position mit Betrag.');
     const raus = [];
     for (const e of auftrag.empfaenger) {
         let owner = e.owner;
         if (owner == null) {
             if (standard !== 'owner' && standard !== 'staff') {
-                throw new RangeError("Zahlbetrag: tipRecipient fehlt ('owner' oder 'staff', wie der angemeldete Kassen-Benutzer).");
+                throw new ReceiptDueError('tip_recipient_missing', "tipRecipient fehlt ('owner' oder 'staff', wie der angemeldete Kassen-Benutzer).");
             }
             owner = standard === 'owner';
         }
@@ -136,7 +179,7 @@ function trinkgeldPositionen(auftrag, positionen, standard) {
         }
         const teile = splitOwnerTip(e.cents, basis);
         if (teile.length === 0)
-            throw new RangeError('Zahlbetrag: Inhaber-Trinkgeld braucht mindestens eine Position mit Betrag.');
+            throw new ReceiptDueError('tip_without_goods', 'Inhaber-Trinkgeld braucht mindestens eine Position mit Betrag.');
         for (const teil of teile) {
             if (teil.cents !== 0)
                 raus.push({ amount: 1, priceOne: teil.cents / 100, vat: teil.vat, tip: 'owner' });

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

@@ -6,4 +6,4 @@ 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 ReceiptDueTip, type ReceiptDueTipRecipient, type ReceiptDueOptions, type ReceiptDueBuckets, type ReceiptDueBreakdown, receiptDueCents, receiptDueBreakdown, } from './due.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,4 @@ 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 { receiptDueCents, receiptDueBreakdown, } from './due.js';
+export { receiptDueCents, receiptDueBreakdown, ReceiptDueError, RECEIPT_DUE_ERROR_REASONS, isReceiptDueError, } from './due.js';

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

@@ -107,3 +107,4 @@ export declare function invalidStoredPosSettings(stored: {
  * weg.
  */
 export declare function fromStoredArticle(id: string, stored: unknown): PosArticle;
+export { fromStoredLayout, toStoredLayout, fromStoredPrintLogo, toStoredPrintLogo } from './layout.js';

package/dist/esm/stored/index.js

@@ -215,3 +215,5 @@ export function invalidStoredPosSettings(stored) {
 export function fromStoredArticle(id, stored) {
     return fromPosArticlePayload(_storedArticleToWire(id, stored));
 }
+// ---- Zeilenmodell und Drucklogo ----------------------------------------------
+export { fromStoredLayout, toStoredLayout, fromStoredPrintLogo, toStoredPrintLogo } from './layout.js';

package/dist/esm/stored/layout.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Zeilenmodell und Drucklogo in der inneren Form (deutsch) <-> Form 1.0.
+ *
+ * Die innere Form ist die, die das Backend speichert und am Draht `/api`
+ * (Kanal intern) spricht, und die, in der 0.x das Zeilenmodell im Browser
+ * zwischengespeichert hat:
+ *
+ * - Zeilenmodell: `regelwerk` statt `ruleset`, Bannerzeilen mit `ton`
+ *   (`belegart`, `warnung`) statt `tone` (`receipt_type`, `warning`);
+ * - Drucklogo (`createPrintJob`, Parameter `logo`): `stufe`, `pxBreite`,
+ *   `pxHoehe`, `breite`, `hoehe`, `zeilen` (Base64, MSB zuerst) statt
+ *   [PrintLogo] (`size`, `pixelWidth`, `pixelHeight`, `raster`).
+ *
+ * Dieselben Namen wie der Rand des Backends unter `/v3` (Vokabular
+ * `createPrintJob`/`getReceiptWithCompany`: `layout.ruleset` <-> `regelwerk`,
+ * `lines[].tone` <-> `ton`, Katalog `LAYOUT_TON`, `logo.scale` <-> `stufe` ...).
+ * Ein unbekannter Ton geht woertlich durch, wie ihn auch der Rand durchreicht.
+ */
+import type { ReceiptLayout } from '../receipt/layout.js';
+import type { PrintLogo } from '../receipt/layout-escpos.js';
+/**
+ * Ein Zeilenmodell in der inneren Form (0.x-Zwischenspeicher, Antwort unter
+ * `/api`) als [ReceiptLayout]. Nimmt auch die Form 1.0 an und laesst sie
+ * unveraendert; so liest eine Funktion alte und neue Eintraege. Die
+ * Reihenfolge der Schluessel bleibt.
+ *
+ * `null`, wenn es kein ganzes Zeilenmodell ist: fehlt, kein Objekt, keine
+ * oder leere `lines`, eine Zeile, die kein Objekt ist, oder kein `paperSize`.
+ * Dann baut der Aufrufer neu (`receiptLayoutFromResult` aus Beleg, Firma und
+ * `testCashregister`/`testSignature`), und TESTKASSE und die Warnzeilen
+ * stehen wieder da. Ein halb lesbares Zeilenmodell gewaenne sonst immer.
+ */
+export declare function fromStoredLayout(stored: unknown): ReceiptLayout | null;
+/**
+ * Ein [ReceiptLayout] in der inneren Form, fuer einen Aufruf unter `/api`
+ * (`createPrintJob`, `renderBelegPdfAdmin`) oder einen Leser der 0.x-Form,
+ * in der Reihenfolge der Schluessel wie 0.31 (`lines`, `paperSize`,
+ * `regelwerk`, sofern die Eingabe sie so hat). Ohne diese Uebersetzung liest
+ * das Backend den Ton nicht, und der Rahmen der Warnzeilen (TESTKASSE,
+ * Sicherheitseinrichtung ausgefallen) und des Belegart-Aufdrucks fiele am
+ * Bon und im PDF weg.
+ */
+export declare function toStoredLayout(layout: ReceiptLayout): Record<string, unknown>;
+/**
+ * Ein [PrintLogo] in der inneren Form des Druckjobs (`createPrintJob` unter
+ * `/api`): dieselben Punkte, die das Paket unter `/v3` als `logo` schickt.
+ */
+export declare function toStoredPrintLogo(logo: PrintLogo): Record<string, unknown>;
+/**
+ * Ein Drucklogo in der inneren Form als [PrintLogo]. Die Zeilen sind die
+ * Rasterzeilen als Base64 (MSB zuerst, jede Zeile auf volle Bytes
+ * aufgefuellt). Wirft `KasseneckValidationError`, wenn Stufe, Masse oder
+ * Zeilen nicht zusammenpassen.
+ */
+export declare function fromStoredPrintLogo(stored: unknown): PrintLogo;

package/dist/esm/stored/layout.js

@@ -0,0 +1,113 @@
+import { rasterRowsBase64 } from '../printing/escpos.js';
+import { KasseneckValidationError } from '../client/errors.js';
+const istObjekt = (w) => w !== null && typeof w === 'object' && !Array.isArray(w);
+const TON_NACH_1_0 = { belegart: 'receipt_type', warnung: 'warning' };
+const TON_NACH_INNEN = { receipt_type: 'belegart', warning: 'warnung' };
+/**
+ * Ein Objekt mit umbenannten Schluesseln, an derselben Stelle: die
+ * Reihenfolge bleibt, damit ein gespeicherter Eintrag byte-gleich
+ * zurueckkommt (Hash- und Cache-Vergleiche). `werte` ersetzt den Wert eines
+ * (alten) Schluessels.
+ */
+function umbenannt(o, namen, werte = {}) {
+    const raus = {};
+    for (const [k, w] of Object.entries(o)) {
+        const neu = namen[k] ?? k;
+        // Traegt die Eingabe beide Namen, gewinnt der schon neue.
+        if (neu !== k && Object.prototype.hasOwnProperty.call(o, neu))
+            continue;
+        raus[neu] = werte[k] ? werte[k](w) : w;
+    }
+    return raus;
+}
+const tonNach = (tabelle) => (w) => (typeof w === 'string' ? tabelle[w] ?? w : w);
+/**
+ * Ein Zeilenmodell in der inneren Form (0.x-Zwischenspeicher, Antwort unter
+ * `/api`) als [ReceiptLayout]. Nimmt auch die Form 1.0 an und laesst sie
+ * unveraendert; so liest eine Funktion alte und neue Eintraege. Die
+ * Reihenfolge der Schluessel bleibt.
+ *
+ * `null`, wenn es kein ganzes Zeilenmodell ist: fehlt, kein Objekt, keine
+ * oder leere `lines`, eine Zeile, die kein Objekt ist, oder kein `paperSize`.
+ * Dann baut der Aufrufer neu (`receiptLayoutFromResult` aus Beleg, Firma und
+ * `testCashregister`/`testSignature`), und TESTKASSE und die Warnzeilen
+ * stehen wieder da. Ein halb lesbares Zeilenmodell gewaenne sonst immer.
+ */
+export function fromStoredLayout(stored) {
+    if (!istObjekt(stored) || !Array.isArray(stored.lines) || stored.lines.length === 0)
+        return null;
+    if (!stored.lines.every(istObjekt))
+        return null;
+    if (typeof stored.paperSize !== 'string' || stored.paperSize === '')
+        return null;
+    return umbenannt(stored, { regelwerk: 'ruleset' }, {
+        lines: (zeilen) => zeilen.map((z) => umbenannt(z, { ton: 'tone' }, { ton: tonNach(TON_NACH_1_0) })),
+    });
+}
+/**
+ * Ein [ReceiptLayout] in der inneren Form, fuer einen Aufruf unter `/api`
+ * (`createPrintJob`, `renderBelegPdfAdmin`) oder einen Leser der 0.x-Form,
+ * in der Reihenfolge der Schluessel wie 0.31 (`lines`, `paperSize`,
+ * `regelwerk`, sofern die Eingabe sie so hat). Ohne diese Uebersetzung liest
+ * das Backend den Ton nicht, und der Rahmen der Warnzeilen (TESTKASSE,
+ * Sicherheitseinrichtung ausgefallen) und des Belegart-Aufdrucks fiele am
+ * Bon und im PDF weg.
+ */
+export function toStoredLayout(layout) {
+    if (!istObjekt(layout) || !Array.isArray(layout.lines)) {
+        throw new KasseneckValidationError('toStoredLayout', 'layout ohne lines', 'request');
+    }
+    return umbenannt(layout, { ruleset: 'regelwerk' }, {
+        lines: (zeilen) => zeilen.map((z) => (istObjekt(z) ? umbenannt(z, { tone: 'ton' }, { tone: tonNach(TON_NACH_INNEN) }) : z)),
+    });
+}
+/**
+ * Ein [PrintLogo] in der inneren Form des Druckjobs (`createPrintJob` unter
+ * `/api`): dieselben Punkte, die das Paket unter `/v3` als `logo` schickt.
+ */
+export function toStoredPrintLogo(logo) {
+    return {
+        stufe: logo.size, pxBreite: logo.pixelWidth, pxHoehe: logo.pixelHeight,
+        breite: logo.raster.width, hoehe: logo.raster.height, zeilen: rasterRowsBase64(logo.raster),
+    };
+}
+const STUFEN = new Set(['S', 'M', 'L', 'XL']);
+const ganz = (w) => typeof w === 'number' && Number.isInteger(w) && w > 0;
+/**
+ * Ein Drucklogo in der inneren Form als [PrintLogo]. Die Zeilen sind die
+ * Rasterzeilen als Base64 (MSB zuerst, jede Zeile auf volle Bytes
+ * aufgefuellt). Wirft `KasseneckValidationError`, wenn Stufe, Masse oder
+ * Zeilen nicht zusammenpassen.
+ */
+export function fromStoredPrintLogo(stored) {
+    const name = 'fromStoredPrintLogo';
+    if (!istObjekt(stored))
+        throw new KasseneckValidationError(name, 'kein Logo-Objekt', 'request');
+    const { stufe, pxBreite, pxHoehe, breite, hoehe, zeilen } = stored;
+    if (typeof stufe !== 'string' || !STUFEN.has(stufe))
+        throw new KasseneckValidationError(name, 'stufe ist nicht S, M, L oder XL', 'request');
+    if (!ganz(pxBreite) || !ganz(pxHoehe) || !ganz(breite) || !ganz(hoehe)) {
+        throw new KasseneckValidationError(name, 'pxBreite, pxHoehe, breite und hoehe muessen ganze Zahlen > 0 sein', 'request');
+    }
+    if (typeof zeilen !== 'string')
+        throw new KasseneckValidationError(name, 'zeilen fehlt', 'request');
+    let binaer;
+    try {
+        binaer = atob(zeilen);
+    }
+    catch {
+        throw new KasseneckValidationError(name, 'zeilen ist kein Base64', 'request');
+    }
+    const byteJeZeile = Math.ceil(breite / 8);
+    if (binaer.length !== byteJeZeile * hoehe)
+        throw new KasseneckValidationError(name, 'zeilen passen nicht zu breite und hoehe', 'request');
+    const dots = new Uint8Array(breite * hoehe);
+    for (let y = 0; y < hoehe; y++) {
+        for (let x = 0; x < breite; x++) {
+            if (binaer.charCodeAt(y * byteJeZeile + (x >> 3)) & (0x80 >> (x & 7)))
+                dots[y * breite + x] = 1;
+        }
+    }
+    const raster = { width: breite, height: hoehe, dots };
+    return { size: stufe, pixelWidth: pxBreite, pixelHeight: pxHoehe, raster };
+}

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-rc.4";
+export declare const PACKAGE_VERSION = "1.0.0";

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-rc.4';
+export const PACKAGE_VERSION = '1.0.0';

package/fixtures/hobex-hps-codes.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.0.0-rc.4",
+  "version": "1.0.0",
   "measuredOn": {
     "tid": "3600335",
     "hpsVersion": "1.10.0",

package/fixtures/invoice-api.schema.json

@@ -2,7 +2,7 @@
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "title": "Kasseneck Rechnungs-API",
   "version": 2,
-  "package": "1.0.0-rc.4",
+  "package": "1.0.0",
   "endpoints": {
     "createCustomer": {
       "request": {

package/fixtures/invoice-texts.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.0.0-rc.4",
+  "version": "1.0.0",
   "languages": [
     "de",
     "en"