@kreiseck/kasseneck-api 0.30.0 → 1.0.0-rc.1

package/dist/esm/stored/einstellungen.js

@@ -0,0 +1,196 @@
+import { POS_BUSINESS_DEFAULTS, POS_BUSINESS_VALUES, POS_DEVICE_DEFAULTS, POS_DEVICE_VALUES, POS_SHORTCUT_DEFAULTS, POS_SHORTCUT_SHARED_PAIRS, } from '../pos/settings.js';
+import { hat, innereNamen, istObjekt, regel } from './draht.js';
+import { KATALOGE, SCHEMAS } from './vokabular.js';
+const bool = (v) => typeof v === 'boolean';
+const hex = (v) => typeof v === 'string' && /^#[0-9a-fA-F]{6}$/.test(v);
+const kuerzel = (v) => typeof v === 'string' && /^[A-Za-z0-9]{1,3}$/.test(v);
+const ganz = (min, max) => (v) => Number.isInteger(v) && v >= min && v <= max;
+const ip = (v) => v === '' || (typeof v === 'string' && /^(\d{1,3}\.){3}\d{1,3}$/.test(v) && v.split('.').every((t) => Number(t) <= 255));
+const kennung = (v) => typeof v === 'string' && v.length <= 64 && /^[\w:.\- ]*$/.test(v);
+// eslint-disable-next-line no-control-regex
+const UNSICHTBAR = /[\u0000-\u001F\u007F-\u009F\u200B-\u200F\u2028\u2029\u202A-\u202E\u2060\u2066-\u2069\uFEFF]/;
+const klartext = (v) => typeof v === 'string' && v.length <= 64 && !UNSICHTBAR.test(v) && (v === '' || v.trim() !== '');
+const tid = (v) => typeof v === 'string' && /^\d{0,16}$/.test(v);
+const prozentChips = (v) => {
+    if (!Array.isArray(v) || v.length > 5)
+        return false;
+    const gesehen = [];
+    for (const x of v) {
+        if (typeof x !== 'number' || !Number.isFinite(x) || x <= 0 || x > 100)
+            return false;
+        const r = Math.round(x * 10) / 10;
+        if (r !== x || gesehen.includes(r))
+            return false;
+        gesehen.push(r);
+    }
+    return true;
+};
+const logoBildUrl = (v) => v === '' || (typeof v === 'string' && v.length <= 600 && v.startsWith('https://firebasestorage.googleapis.com/'));
+/** Pruefer je aeusserem Feld, soweit das Feld keine Aufzaehlung und keine Karte ist. */
+const PRUEFER = {
+    business: {
+        logoText: kuerzel, logoEnabled: bool, color: hex, clock: bool, lockScreen: bool, staffPhotos: bool, logoutAfterSale: bool,
+        fastLogin: bool, showPrices: bool, showVat: bool, emoji: bool, categoryColors: bool, customAmountAllowed: bool,
+        note: bool, search: bool, payCash: bool, payCard: bool, tip: bool, tipSplit: bool, change: bool, exactCash: bool,
+        paySplit: bool, tipChips: prozentChips, logoImage: logoBildUrl, watermarkX: ganz(-25, 125), watermarkY: ganz(-25, 125),
+        glass: bool, hints: bool, discountChips: prozentChips,
+    },
+    device: {
+        extraColumns: ganz(-2, 4), touch: bool, printerEnabled: bool, printerIp: ip, printerPort: ganz(1, 65535),
+        printerBluetoothId: kennung, printerName: klartext, printerId: kennung, printerDeviceId: kennung, connectPrinterId: kennung,
+        drawerEnabled: bool, terminalIp: ip, terminalPort: ganz(1, 65535), terminalTid: tid, shortcutHints: bool,
+    },
+};
+/** Aufzaehlungen (aussen, englisch) je Teil. */
+const AUFZAEHLUNGEN = {
+    business: POS_BUSINESS_VALUES, device: POS_DEVICE_VALUES,
+};
+/** Schalter-Karten: erlaubte Schluessel (Backend STEUERSAETZE, TG_STUFEN = Schluessel der Vorgabe). */
+const KARTEN = {
+    vatRates: Object.keys(POS_BUSINESS_DEFAULTS.vatRates),
+    tipSteps: Object.keys(POS_BUSINESS_DEFAULTS.tipSteps),
+};
+/** Tastenmuster (Backend TASTE_MUSTER). */
+const TASTE_MUSTER = /^((Ctrl|Alt|Shift|Meta|Mod)\+){0,3}([A-Z0-9]|F\d{1,2}|Enter|Escape|Backspace|Space|Tab|Delete|Arrow(Up|Down|Left|Right)|[+\-*/.,])$/;
+/** Schema-Teil (aussen -> innen) und die Kataloge seiner Werte. */
+function teilSchema(teil) {
+    return regel(SCHEMAS.getKasseSettings.data[teil]).unter;
+}
+function katalogFuer(teil, aussen) {
+    const verweis = SCHEMAS.getKasseSettings.werte[`${teil}.${aussen}`];
+    return verweis ? KATALOGE[verweis.$catalog] ?? null : null;
+}
+/** Tasten: aeussere und innere Aktionsnamen, Vorgabe und Paare in innerer Form. */
+const TASTEN_SCHEMA = regel(teilSchema('device').shortcuts).unter;
+const AKTION_AUSSEN = innereNamen(TASTEN_SCHEMA); // innen -> aussen
+const AKTION_INNEN = new Map([...AKTION_AUSSEN].map(([i, a]) => [a, i]));
+const innen = (aktion) => AKTION_INNEN.get(aktion) ?? aktion;
+const TASTEN_VORGABE_INNEN = Object.fromEntries(Object.entries(POS_SHORTCUT_DEFAULTS).map(([a, t]) => [innen(a), [...t]]));
+const darfTeilen = (a, b) => POS_SHORTCUT_SHARED_PAIRS.some(([x, y]) => (innen(x) === a && innen(y) === b) || (innen(x) === b && innen(y) === a));
+/** Zwilling von `entwirreTasten`: die gespeicherte Wahl gewinnt, eine beanspruchte Vorgabe-Taste faellt. */
+function entwirreTasten(gemischt, gespeichert) {
+    const beansprucht = new Map();
+    for (const [aktion, tasten] of Object.entries(gespeichert)) {
+        if (!Array.isArray(tasten))
+            continue;
+        for (const t of tasten)
+            beansprucht.set(t, aktion);
+    }
+    const raus = {};
+    for (const [aktion, tasten] of Object.entries(gemischt)) {
+        if (!Array.isArray(tasten) || aktion in gespeichert) {
+            raus[aktion] = tasten;
+            continue;
+        }
+        raus[aktion] = tasten.filter((t) => {
+            const inhaber = beansprucht.get(t);
+            return !inhaber || inhaber === aktion || darfTeilen(inhaber, aktion);
+        });
+    }
+    return raus;
+}
+/** Nimmt `tastenkarte` diesen einen Eintrag an? (bekannte Aktion, 0-3 Tasten im Muster) */
+function tasteGueltig(aktion, tasten) {
+    if (!AKTION_AUSSEN.has(aktion))
+        return false;
+    return Array.isArray(tasten) && tasten.length <= 3 && tasten.every((t) => typeof t === 'string' && TASTE_MUSTER.test(t));
+}
+/**
+ * Ein Aufzaehlungswert: gueltig (innen bekannt), unbekannt vom richtigen Typ
+ * (bleibt, siehe oben) oder ungueltig. Innen gilt die Liste des Servers, also
+ * die aeussere Liste durch den Katalog zurueck: ein englischer Wert im
+ * gespeicherten Stand (`stil: 'night'`) ist dort ungueltig.
+ */
+function aufzaehlung(liste, katalog, w) {
+    const zurueck = new Map(Object.entries(katalog ?? {}).map(([i, a]) => [a, i]));
+    const innenListe = liste.map((a) => (typeof a === 'string' && zurueck.has(a) ? zurueck.get(a) : a));
+    if (innenListe.includes(w))
+        return 'gueltig';
+    if (typeof w !== typeof liste[0])
+        return 'ungueltig';
+    if (liste.includes(w) || zurueck.has(w))
+        return 'ungueltig';
+    return 'unbekannt';
+}
+function teilNachAussen(teil, gespeichert, weg) {
+    if (!istObjekt(gespeichert))
+        return {};
+    const schema = teilSchema(teil);
+    const aussenName = innereNamen(schema); // innen -> aussen
+    const raus = {};
+    for (const [k, w] of Object.entries(gespeichert)) {
+        const aussen = aussenName.get(k);
+        // mische: was innen unbekannt ist, kommt gar nicht erst in den Stand.
+        if (aussen === undefined || w === undefined)
+            continue;
+        const pfad = `${teil}.${aussen}`;
+        if (aussen === 'shortcuts') {
+            if (!w || typeof w !== 'object') {
+                weg.push(pfad);
+                continue;
+            }
+            let gemischt = Object.assign({}, TASTEN_VORGABE_INNEN, w);
+            if (!Array.isArray(w))
+                gemischt = entwirreTasten(gemischt, w);
+            const karte = {};
+            for (const [aktion, tasten] of Object.entries(gemischt)) {
+                if (tasteGueltig(aktion, tasten))
+                    karte[AKTION_AUSSEN.get(aktion)] = tasten;
+                else
+                    weg.push(`${pfad}.${AKTION_AUSSEN.get(aktion) ?? aktion}`);
+            }
+            raus[aussen] = karte;
+            continue;
+        }
+        if (hat(KARTEN, aussen)) {
+            if (!w || typeof w !== 'object') {
+                weg.push(pfad);
+                continue;
+            }
+            const karte = {};
+            for (const [sk, sw] of Object.entries(w)) {
+                if (KARTEN[aussen].includes(sk) && typeof sw === 'boolean')
+                    karte[sk] = sw;
+                else
+                    weg.push(`${pfad}.${sk}`);
+            }
+            raus[aussen] = karte;
+            continue;
+        }
+        const liste = AUFZAEHLUNGEN[teil][aussen];
+        if (liste) {
+            const katalog = katalogFuer(teil, aussen);
+            const art = aufzaehlung(liste, katalog, w);
+            if (art === 'ungueltig') {
+                weg.push(pfad);
+                continue;
+            }
+            raus[aussen] = katalog && typeof w === 'string' && hat(katalog, w) ? katalog[w] : w;
+            continue;
+        }
+        const pruefer = PRUEFER[teil][aussen];
+        if (pruefer && pruefer(w))
+            raus[aussen] = w;
+        else
+            weg.push(pfad);
+    }
+    return raus;
+}
+/**
+ * Gespeicherte Einstellungen `{ betrieb, geraet }` in der Drahtform, nur die
+ * gespeicherten und gueltigen Felder (die Vorgaben mischt der Leser dazu),
+ * und die weggelassenen aeusseren Pfade.
+ */
+export function _storedPosSettingsToWire(stored) {
+    const s = istObjekt(stored) ? stored : {};
+    const weg = [];
+    const business = teilNachAussen('business', s.betrieb, weg);
+    const device = teilNachAussen('device', s.geraet, weg);
+    return { business, device, weggelassen: weg };
+}
+/** Nur fuer den Test: die Feldliste der Pruefer (muss mit der Vorgabe deckungsgleich sein). */
+export const _PRUEFER_FELDER = Object.freeze({
+    business: [...Object.keys(PRUEFER.business), ...Object.keys(POS_BUSINESS_VALUES), ...Object.keys(KARTEN)],
+    device: [...Object.keys(PRUEFER.device), ...Object.keys(POS_DEVICE_VALUES), 'shortcuts'],
+    standard: { business: Object.keys(POS_BUSINESS_DEFAULTS), device: Object.keys(POS_DEVICE_DEFAULTS) },
+});

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

@@ -0,0 +1,109 @@
+/**
+ * `@kreiseck/kasseneck-api/stored`: gespeicherte Firestore-Dokumente (innen,
+ * deutsch) als dieselben englischen Modelle, die der Draht `/v3` liefert.
+ *
+ * Fuer Verbraucher, die Firestore direkt lesen (Admin-Panel, Echtzeit-Listener
+ * auf Belege). So gibt es in 1.0 ein englisches Modell und keinen zweiten
+ * Draht-Dialekt: jede Funktion hier uebersetzt das Dokument genau so, wie der
+ * Server es unter `/v3` bzw. `/api/v3` hinausgibt (Schluessel und Werte aus
+ * dem Vertrags-Export `fixtures/v3/v3-vokabular.json`), und liest das
+ * Ergebnis dann mit demselben Leser wie eine Antwort. Ein Test haelt jedes
+ * gespeicherte Dokument des Vertrags gegen seine Antwort.
+ *
+ * Belege kommen im Kanal der Kasse (`app`): mit Anbieterdaten der Zahlungen
+ * (`payments[].providerData`/`providerPaymentId`, alte Kartenfelder).
+ */
+import { type ReceiptWithCompany } from '../client/receipts.js';
+import { type ReceiptCompany } from '../models/receipt-company.js';
+import type { Receipt, RegistrationInfo } from '../models/receipt.js';
+import { type PosSettings } from '../pos/settings.js';
+import { type PosArticle } from '../pos/artikel.js';
+/** Ein Firestore-Dokument mit seiner Kennung (die nicht in den Daten steht). */
+export interface StoredDocument {
+    id: string;
+    data: unknown;
+}
+/**
+ * Ein Belegdokument (`users/{uid}/cashregisters/{id}/receipts/{id}`) als
+ * [Receipt], wie `getReceipt` am Kassenweg ihn liefert. Wirft
+ * `KasseneckValidationError`, wenn es kein Belegdokument ist.
+ */
+export declare function fromStoredReceipt(doc: unknown): Receipt;
+export interface StoredReceiptOptions {
+    /**
+     * Die Kopf-Version dieses Belegs (`users/{uid}/beleg_kopf/{id}`): die mit
+     * `receipt.headerVersionId` (gespeichert `kopfId`), bei Altbelegen ohne
+     * Zuordnung die zum Belegzeitpunkt gueltige (`gueltigAb`/`gueltigBis`).
+     */
+    headerVersion: StoredDocument;
+    /**
+     * Das Kontodokument (`users/{uid}`): Logo, wenn die Version noch keines
+     * kennt, und die Logo-Stufe (`register_settings.kasse.logoSkala`).
+     */
+    account?: unknown;
+    /** Konto einer Testumgebung (Aufdruck TESTKASSE, keine Testsignatur-Warnung). */
+    testCashregister?: boolean;
+    /**
+     * Registrierdaten fuer einen Nullbeleg, der sie nicht selbst traegt
+     * (Altbestand; der Server schlaegt sie an Karte und Kasse nach). Fehlt die
+     * Angabe, bleiben beide Zeitpunkte leer.
+     */
+    registrationInfo?: RegistrationInfo;
+}
+/**
+ * Ein Belegdokument samt Firma und Layout, wie `getReceiptWithCompany` am
+ * Kassenweg es liefert: Kopf und Fuss aus der Kopf-Version, das Layout mit
+ * demselben Regelwerk und in derselben Breite (80 mm) wie am Server.
+ */
+export declare function fromStoredReceiptWithCompany(doc: unknown, options: StoredReceiptOptions): ReceiptWithCompany;
+/**
+ * Eine Kopf-Version (`users/{uid}/beleg_kopf/{id}`) als [ReceiptCompany], wie
+ * die Beleg-Antwort sie traegt. `receipt`: ein Nullbeleg traegt kein Logo;
+ * `account`: kennt die Version noch kein Logo, gilt das des Kontos.
+ */
+export declare function fromStoredCompany(headerVersion: unknown, options?: {
+    account?: unknown;
+    receipt?: {
+        receiptType?: unknown;
+    };
+}): ReceiptCompany;
+/**
+ * Gespeicherte Kassen-Einstellungen als [PosSettings], wie `getKasseSettings`
+ * am Kassenweg sie liefert: `betrieb` aus
+ * `users/{uid}.register_settings.kasse`, `geraet` aus
+ * `users/{uid}/register_devices/{id}.kasse` (fehlt = Vorgaben).
+ *
+ * Wie am Server faellt weg, was der Validator beim Lesen nicht annimmt: ein
+ * fremder Steuersatz oder eine fremde Trinkgeldstufe, eine unbekannte
+ * Tasten-Aktion (erst nach dem Entwirren der Tasten, wie `mische`), eine Taste
+ * ausserhalb des Musters, ein Wert ausserhalb seines Bereichs oder Musters
+ * (`wzPos: 500`, Farbe, IP). An seiner Stelle steht die Vorgabe;
+ * [invalidStoredPosSettings] nennt jeden solchen Pfad. So schickt ein
+ * spaeteres Speichern nie einen Eintrag, den der Server abweist.
+ *
+ * Einzige Ausnahme: ein unbekannter Wert eines Aufzaehlungsfeldes vom
+ * richtigen Typ (`stil: 'sepia'`) bleibt woertlich stehen wie ein unbekannter
+ * Wert vom Draht; [unknownPosSettingValues] nennt ihn. Reste der inneren Form
+ * 0.x fallen auf die Vorgabe zurueck.
+ */
+export declare function fromStoredPosSettings(stored: {
+    betrieb?: unknown;
+    geraet?: unknown;
+} | null | undefined): PosSettings;
+/**
+ * Die aeusseren Pfade (`business.watermarkX`, `business.vatRates.7`,
+ * `device.shortcuts.cash`), deren gespeicherten Wert der Server beim Lesen
+ * weglaesst und [fromStoredPosSettings] darum durch die Vorgabe ersetzt. Fuer
+ * die Anzeige „gespeicherter Wert ungueltig, Vorgabe gilt“.
+ */
+export declare function invalidStoredPosSettings(stored: {
+    betrieb?: unknown;
+    geraet?: unknown;
+} | null | undefined): string[];
+/**
+ * Ein Artikeldokument (`users/{uid}/articles/{id}`) als [PosArticle], wie
+ * `listMyArticles` am Kassenweg ihn liefert. Felder, die kein Schreibweg
+ * kennt, und Katalogwerte, die der Vertrag nicht kennt, fallen wie am Server
+ * weg.
+ */
+export declare function fromStoredArticle(id: string, stored: unknown): PosArticle;

package/dist/esm/stored/index.js

@@ -0,0 +1,217 @@
+/**
+ * `@kreiseck/kasseneck-api/stored`: gespeicherte Firestore-Dokumente (innen,
+ * deutsch) als dieselben englischen Modelle, die der Draht `/v3` liefert.
+ *
+ * Fuer Verbraucher, die Firestore direkt lesen (Admin-Panel, Echtzeit-Listener
+ * auf Belege). So gibt es in 1.0 ein englisches Modell und keinen zweiten
+ * Draht-Dialekt: jede Funktion hier uebersetzt das Dokument genau so, wie der
+ * Server es unter `/v3` bzw. `/api/v3` hinausgibt (Schluessel und Werte aus
+ * dem Vertrags-Export `fixtures/v3/v3-vokabular.json`), und liest das
+ * Ergebnis dann mit demselben Leser wie eine Antwort. Ein Test haelt jedes
+ * gespeicherte Dokument des Vertrags gegen seine Antwort.
+ *
+ * Belege kommen im Kanal der Kasse (`app`): mit Anbieterdaten der Zahlungen
+ * (`payments[].providerData`/`providerPaymentId`, alte Kartenfelder).
+ */
+import { belegAusHuelle, belegMitFirmaAusHuelle } from '../client/receipts.js';
+import { fromReceiptCompanyPayload } from '../models/receipt-company.js';
+import { buildReceiptLayout, CURRENT_LAYOUT_RULESET, receiptSignatureIsTest } from '../receipt/layout.js';
+import { sanitizePosSettings } from '../pos/settings.js';
+import { fromPosArticlePayload } from '../pos/artikel.js';
+import { KasseneckValidationError } from '../client/errors.js';
+import { _receiptEnvelopeToWire, _storedArticleToWire, _storedReceiptInner, _storedReceiptToWire, pruefangabenDerHuelle, } from './draht.js';
+import { _storedPosSettingsToWire } from './einstellungen.js';
+const istObjekt = (w) => w !== null && typeof w === 'object' && !Array.isArray(w);
+// ---- Belege -----------------------------------------------------------------
+/**
+ * Ein Belegdokument (`users/{uid}/cashregisters/{id}/receipts/{id}`) als
+ * [Receipt], wie `getReceipt` am Kassenweg ihn liefert. Wirft
+ * `KasseneckValidationError`, wenn es kein Belegdokument ist.
+ */
+export function fromStoredReceipt(doc) {
+    return belegAusHuelle({ receipt: zeilenAlsText(_storedReceiptToWire(doc, 'fromStoredReceipt')) }, 'fromStoredReceipt');
+}
+/**
+ * Freitextzeilen (`customerDetails`, `legalMessage`) als Liste gespeichert:
+ * als Text mit Zeilenumbruechen lesen, wie das Layout am Server
+ * (beleg-layout.belegPayload). Bewusst nachsichtiger als der Draht: dort
+ * geht die Liste woertlich hinaus, und der Leser des Pakets scheitert an ihr
+ * (Backend-Folgepunkt: Huelle oder Leser). Das Panel soll anzeigen statt
+ * abzustuerzen.
+ */
+function zeilenAlsText(beleg) {
+    const raus = { ...beleg };
+    for (const feld of ['customerDetails', 'legalMessage']) {
+        const w = raus[feld];
+        if (Array.isArray(w))
+            raus[feld] = w.filter(Boolean).join('\n');
+    }
+    return raus;
+}
+/**
+ * Ein Belegdokument samt Firma und Layout, wie `getReceiptWithCompany` am
+ * Kassenweg es liefert: Kopf und Fuss aus der Kopf-Version, das Layout mit
+ * demselben Regelwerk und in derselben Breite (80 mm) wie am Server.
+ */
+export function fromStoredReceiptWithCompany(doc, options) {
+    const name = 'fromStoredReceiptWithCompany';
+    if (!istObjekt(options) || !istObjekt(options.headerVersion) || typeof options.headerVersion.id !== 'string') {
+        throw new KasseneckValidationError(name, 'headerVersion { id, data } fehlt', 'request');
+    }
+    const beleg = _storedReceiptInner(doc, name);
+    // Die Version muss die des Belegs sein: sonst zeigte er still den heutigen
+    // Kopf statt des eingefrorenen (BAO § 131). Altbelege ohne kopfId waehlt der
+    // Aufrufer ueber das Zeitfenster.
+    if (typeof beleg.kopfId === 'string' && beleg.kopfId !== options.headerVersion.id) {
+        throw new KasseneckValidationError(name, `headerVersion ${options.headerVersion.id} ist nicht die Kopf-Version des Belegs (${beleg.kopfId})`, 'request');
+    }
+    const testKasse = options.testCashregister === true;
+    const huelle = {
+        receipt: beleg,
+        ...betriebsfelder(options.headerVersion.data, options.account, beleg),
+        logo_skala: logoStufe(options.account),
+        kopfId: options.headerVersion.id,
+        pruefangaben: pruefangabenFuer(beleg, options.registrationInfo),
+        testSignatur: receiptSignatureIsTest({ qr: typeof beleg.qr === 'string' ? beleg.qr : '' }) && !testKasse,
+        testKasse,
+    };
+    const draht = _receiptEnvelopeToWire(huelle);
+    draht.receipt = zeilenAlsText(draht.receipt);
+    const raus = belegMitFirmaAusHuelle(draht, name);
+    raus.layout = layoutWieServer(raus, beleg.layoutRegeln);
+    return raus;
+}
+/**
+ * Registrierdaten der Huelle wie `pruefangabenFuerBeleg`: nur Nullbelege;
+ * festgehaltene `pruefangaben` des Belegs gehen vor, sonst die Angabe des
+ * Aufrufers (der Server schlaegt dann an Karte und Kasse nach), sonst leer.
+ */
+function pruefangabenFuer(beleg, angabe) {
+    if (beleg.receiptType !== 'zero')
+        return null;
+    if (beleg.pruefangaben && typeof beleg.pruefangaben === 'object')
+        return pruefangabenDerHuelle(beleg.pruefangaben);
+    return { karteRegistriertAm: angabe?.cardRegisteredAt ?? null, kasseRegistriertAm: angabe?.cashregisterRegisteredAt ?? null };
+}
+/**
+ * Layout wie `beleg-layout.layoutFuerBeleg`: 80 mm, Regelwerk mindestens das
+ * aktuelle. Kann der Server es nicht bauen, liefert er `null` (dann baut
+ * [receiptLayoutFromResult] selbst); ebenso hier.
+ */
+function layoutWieServer(b, regelwerk) {
+    const ruleset = Math.max(Number(regelwerk) || 1, CURRENT_LAYOUT_RULESET);
+    try {
+        return buildReceiptLayout(b.receipt, b.company, {
+            paperSize: 'mm80', ruleset, testCashregister: b.testCashregister, testSignature: b.testSignature, registrationInfo: b.registrationInfo,
+        });
+    }
+    catch {
+        return null;
+    }
+}
+// ---- Firma ------------------------------------------------------------------
+const KOPF_FELDER = ['companyName', 'street', 'zip', 'city', 'phone', 'uid', 'taxnr', 'isSmallBusiness',
+    'footer1', 'footer2', 'footer3', 'footer4', 'thanksMessage', 'showKreiseckLogo', 'logoUrl'];
+/** Zwilling von `beleg-kopf-core.nurKopf`: Luecken der Version mit denselben Vorgaben. */
+function nurKopf(version) {
+    const v = istObjekt(version) ? version : {};
+    const raus = {};
+    for (const f of KOPF_FELDER) {
+        if (f === 'logoUrl') {
+            if (v.logoUrl !== undefined)
+                raus.logoUrl = v.logoUrl;
+            continue;
+        }
+        raus[f] = v[f] !== undefined ? v[f]
+            : f === 'thanksMessage' ? []
+                : f === 'isSmallBusiness' || f === 'showKreiseckLogo' ? false
+                    : f === 'uid' || f.startsWith('footer') ? null : '';
+    }
+    return raus;
+}
+/**
+ * Betriebsfelder der Beleg-Huelle aus einer Kopf-Version (Zwilling von
+ * `alsBetriebPayload` und `logoFuerBeleg`, beleg-kopf-core.js): innere
+ * Namen (`uid`, `taxnr`), die der Rand dann uebersetzt.
+ */
+function betriebsfelder(version, account, beleg) {
+    const k = nurKopf(version);
+    // Nachsichtiger als der Server: ein Dank als Zeichenkette (moeglich ueber
+    // nachtragKopf) laesst belegAntwort scheitern (`join`), hier bleibt er leer.
+    const dank = Array.isArray(k.thanksMessage) ? k.thanksMessage : [];
+    const konto = istObjekt(account) ? account : {};
+    let logo;
+    if (beleg && beleg.receiptType === 'zero')
+        logo = null;
+    else if (istObjekt(version) && version.logoUrl !== undefined)
+        logo = version.logoUrl || null;
+    else
+        logo = (typeof konto.logo_url === 'string' && konto.logo_url) || null;
+    return {
+        company: k.companyName, street: k.street, zip: k.zip, city: k.city, phone: k.phone,
+        uid: k.uid, taxnr: k.taxnr, is_small_business: k.isSmallBusiness,
+        footer1: k.footer1, footer2: k.footer2, footer3: k.footer3, footer4: k.footer4,
+        thanks_message: dank.length ? dank.join('\n') : null,
+        kreiseck_logo: k.showKreiseckLogo,
+        logo_url: logo,
+    };
+}
+/** Zwilling von `logoStufeFuerKonto`: Kasse-Einstellung `logoSkala`, sonst M. */
+function logoStufe(account) {
+    const konto = istObjekt(account) ? account : {};
+    const rs = istObjekt(konto.register_settings) ? konto.register_settings : {};
+    const kasse = istObjekt(rs.kasse) ? rs.kasse : {};
+    return ['S', 'M', 'L', 'XL'].includes(kasse.logoSkala) ? kasse.logoSkala : 'M';
+}
+/**
+ * Eine Kopf-Version (`users/{uid}/beleg_kopf/{id}`) als [ReceiptCompany], wie
+ * die Beleg-Antwort sie traegt. `receipt`: ein Nullbeleg traegt kein Logo;
+ * `account`: kennt die Version noch kein Logo, gilt das des Kontos.
+ */
+export function fromStoredCompany(headerVersion, options = {}) {
+    const draht = _receiptEnvelopeToWire(betriebsfelder(headerVersion, options.account, options.receipt));
+    return fromReceiptCompanyPayload(draht);
+}
+// ---- Kassen-Einstellungen ------------------------------------------------------
+/**
+ * Gespeicherte Kassen-Einstellungen als [PosSettings], wie `getKasseSettings`
+ * am Kassenweg sie liefert: `betrieb` aus
+ * `users/{uid}.register_settings.kasse`, `geraet` aus
+ * `users/{uid}/register_devices/{id}.kasse` (fehlt = Vorgaben).
+ *
+ * Wie am Server faellt weg, was der Validator beim Lesen nicht annimmt: ein
+ * fremder Steuersatz oder eine fremde Trinkgeldstufe, eine unbekannte
+ * Tasten-Aktion (erst nach dem Entwirren der Tasten, wie `mische`), eine Taste
+ * ausserhalb des Musters, ein Wert ausserhalb seines Bereichs oder Musters
+ * (`wzPos: 500`, Farbe, IP). An seiner Stelle steht die Vorgabe;
+ * [invalidStoredPosSettings] nennt jeden solchen Pfad. So schickt ein
+ * spaeteres Speichern nie einen Eintrag, den der Server abweist.
+ *
+ * Einzige Ausnahme: ein unbekannter Wert eines Aufzaehlungsfeldes vom
+ * richtigen Typ (`stil: 'sepia'`) bleibt woertlich stehen wie ein unbekannter
+ * Wert vom Draht; [unknownPosSettingValues] nennt ihn. Reste der inneren Form
+ * 0.x fallen auf die Vorgabe zurueck.
+ */
+export function fromStoredPosSettings(stored) {
+    const { business, device } = _storedPosSettingsToWire(stored);
+    return sanitizePosSettings({ business, device });
+}
+/**
+ * Die aeusseren Pfade (`business.watermarkX`, `business.vatRates.7`,
+ * `device.shortcuts.cash`), deren gespeicherten Wert der Server beim Lesen
+ * weglaesst und [fromStoredPosSettings] darum durch die Vorgabe ersetzt. Fuer
+ * die Anzeige „gespeicherter Wert ungueltig, Vorgabe gilt“.
+ */
+export function invalidStoredPosSettings(stored) {
+    return _storedPosSettingsToWire(stored).weggelassen;
+}
+// ---- Artikel ------------------------------------------------------------------
+/**
+ * Ein Artikeldokument (`users/{uid}/articles/{id}`) als [PosArticle], wie
+ * `listMyArticles` am Kassenweg ihn liefert. Felder, die kein Schreibweg
+ * kennt, und Katalogwerte, die der Vertrag nicht kennt, fallen wie am Server
+ * weg.
+ */
+export function fromStoredArticle(id, stored) {
+    return fromPosArticlePayload(_storedArticleToWire(id, stored));
+}

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

@@ -0,0 +1,18 @@
+/** Fingerabdruck des Vertrags-Exports, aus dem diese Datei stammt (`_quelle.sha256`). */
+export declare const VOKABULAR_QUELLE = "29994ca53adc96e7cb49b9e3688b102a69c126544ef092fc6579a2e1fcd0d555";
+/** Schema-Notation des Vertrags: Blatt 'aussen': 'innen', Objekt { __: 'innen', ... }, Liste [ { __: 'innen', ... } ]. */
+export type SchemaEintrag = string | SchemaObjekt | readonly [SchemaObjekt];
+export interface SchemaObjekt {
+    readonly [aussen: string]: SchemaEintrag;
+}
+/** Schema je Endpunkt (aussen -> innen) und Wertverweise auf die Kataloge. */
+export declare const SCHEMAS: Readonly<Record<'getReceipt' | 'getKasseSettings' | 'listMyArticles', {
+    readonly data: SchemaObjekt;
+    readonly werte: Readonly<Record<string, {
+        readonly $catalog: string;
+    }>>;
+}>>;
+/** Die Felder eines Artikels in der Antwort (`listMyArticles`), aussen. */
+export declare const ARTIKEL_FELDER: readonly string[];
+/** Wertkataloge innen (deutsch) -> aussen (englisch). */
+export declare const KATALOGE: Readonly<Record<string, Readonly<Record<string, string>>>>;