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

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

@@ -0,0 +1,90 @@
+import type { InternerTransport } from '../client/aufrufe.js';
+/**
+ * Artikelgruppen (Kategorien der Kachel-Kasse) und Artikel in der Form, die
+ * die Kacheln brauchen, Backend: `article-endpoints.js`
+ * (`listMyArticleGroups`, `listMyArticles` mit `groupId`/`tile`).
+ */
+export interface ArticleGroup {
+    id: string;
+    name: string;
+    /** #RRGGBB */
+    color: string;
+    /** Kategorie-Symbol (Emoji, hoechstens zwei Zeichen) oder null. */
+    symbol: string | null;
+    sort: number;
+    vatRate: number | null;
+}
+export interface ArticleGroupPayload {
+    id?: string | null;
+    name?: string | null;
+    color?: string | null;
+    symbol?: string | null;
+    sort?: number | null;
+    vatRate?: number | null;
+}
+export declare function fromArticleGroupPayload(p: ArticleGroupPayload): ArticleGroup;
+/**
+ * Mengenregel eines Artikels (Draht `quantityRule`): `piece` = ganze Stueck
+ * (1, 2, 3 ...), `decimal` = Kommamenge in der Einheit (0,250 kg, 1,5 m).
+ * Beleg und DEP bleiben ganzzahlig: eine Kommamenge wird an der Kasse als EINE
+ * Position mit ausgerechnetem Betrag gebucht, die Bezeichnung traegt die Menge
+ * („Wurst 0,250 kg“). Siehe [quantityRuleForUnit] fuer die Vorgabe je Einheit.
+ */
+export declare const QUANTITY_RULES: readonly ["piece", "decimal"];
+export type QuantityRule = typeof QUANTITY_RULES[number];
+export interface QuantityDefaults {
+    rule: QuantityRule;
+    /** Kasse fragt beim Antippen nach der Menge (Wurst nach Gewicht: ja; Semmel: nein). */
+    ask: boolean;
+    /** Nachkommastellen bei `decimal`. */
+    decimals: number;
+}
+/** Vorgabe je Einheit: was der Betrieb bei einem neuen Artikel bekommt und aendern darf. */
+export declare function quantityRuleForUnit(unit: string | null | undefined): QuantityDefaults;
+/** Wirksame Regel eines Artikels: gespeicherte Angabe schlaegt die Vorgabe der Einheit. */
+export declare function quantityDefaults(a: Pick<PosArticle, 'unit' | 'quantityRule' | 'askQuantity'>): QuantityDefaults;
+/** Artikel, wie ihn die Kasse fuer Kacheln und Belegpositionen braucht. */
+export interface PosArticle {
+    id: string;
+    name: string;
+    unitPriceCents: number | null;
+    vatRate: number | null;
+    unit: string;
+    groupId: string | null;
+    /** Erloesgruppe (Buchhaltung); null = keine. */
+    revenueGroupId: string | null;
+    /** Kachel sichtbar (Draht `tile.visible`, fehlt = sichtbar). */
+    visible: boolean;
+    /** Reihenfolge der Kachel (Draht `tile.sort`). */
+    sort: number;
+    active: boolean;
+    /** Gespeicherte Mengenregel; null = Vorgabe der Einheit. */
+    quantityRule: QuantityRule | null;
+    /** Gespeichert: Kasse fragt nach der Menge; null = Vorgabe der Einheit. */
+    askQuantity: boolean | null;
+    /** Hoechstmenge je Beleg (bei kg/l/m auch Kommazahl); null = keine Grenze. */
+    maxQuantity: number | null;
+}
+/** Deckelt eine gewuenschte Menge an der Hoechstmenge des Artikels (null = keine Grenze). */
+export declare function allowedQuantity(a: Pick<PosArticle, 'maxQuantity'>, wanted: number): number;
+/** Ein Artikel am Draht `/api/v3` (`listMyArticles`), soweit dieses Paket ihn liest. */
+export interface PosArticlePayload {
+    id?: string | null;
+    name?: string | null;
+    unitPriceCents?: number | null;
+    vatRate?: number | null;
+    unit?: string | null;
+    groupId?: string | null;
+    revenueGroupId?: string | null;
+    tile?: {
+        visible?: boolean | null;
+        sort?: number | null;
+    } | null;
+    active?: boolean | null;
+    quantityRule?: string | null;
+    askQuantity?: boolean | null;
+    maxQuantity?: number | null;
+}
+export declare function fromPosArticlePayload(p: PosArticlePayload): PosArticle;
+export declare function listMyArticleGroups(transport: InternerTransport): Promise<ArticleGroup[]>;
+export declare function listMyArticles(transport: InternerTransport): Promise<PosArticle[]>;

package/dist/cjs/pos/artikel.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QUANTITY_RULES = void 0;
+exports.fromArticleGroupPayload = fromArticleGroupPayload;
+exports.quantityRuleForUnit = quantityRuleForUnit;
+exports.quantityDefaults = quantityDefaults;
+exports.allowedQuantity = allowedQuantity;
+exports.fromPosArticlePayload = fromPosArticlePayload;
+exports.listMyArticleGroups = listMyArticleGroups;
+exports.listMyArticles = listMyArticles;
+const errors_js_1 = require("../client/errors.js");
+function fromArticleGroupPayload(p) {
+    return {
+        id: p.id ?? '',
+        name: p.name ?? '',
+        color: p.color ?? '#6B7280',
+        symbol: p.symbol ?? null,
+        sort: typeof p.sort === 'number' ? p.sort : 0,
+        vatRate: typeof p.vatRate === 'number' ? p.vatRate : null,
+    };
+}
+/**
+ * Mengenregel eines Artikels (Draht `quantityRule`): `piece` = ganze Stueck
+ * (1, 2, 3 ...), `decimal` = Kommamenge in der Einheit (0,250 kg, 1,5 m).
+ * Beleg und DEP bleiben ganzzahlig: eine Kommamenge wird an der Kasse als EINE
+ * Position mit ausgerechnetem Betrag gebucht, die Bezeichnung traegt die Menge
+ * („Wurst 0,250 kg“). Siehe [quantityRuleForUnit] fuer die Vorgabe je Einheit.
+ */
+exports.QUANTITY_RULES = ['piece', 'decimal'];
+/** Einheiten, die nach Menge verkauft werden (Kommazahl, Kasse fragt). */
+const DEZIMAL_EINHEITEN = {
+    kg: 3, g: 0, l: 2, ml: 0, m: 2, lfm: 2, km: 1, 'm²': 2, m2: 2, 'm³': 3, m3: 3, std: 2, h: 2, min: 0, t: 3,
+};
+/** Vorgabe je Einheit: was der Betrieb bei einem neuen Artikel bekommt und aendern darf. */
+function quantityRuleForUnit(unit) {
+    const u = (unit ?? '').trim().toLowerCase();
+    if (u in DEZIMAL_EINHEITEN) {
+        const stellen = DEZIMAL_EINHEITEN[u];
+        return stellen === 0
+            ? { rule: 'piece', ask: true, decimals: 0 } // g, ml, min: ganze Zahl, aber die Menge wird gefragt
+            : { rule: 'decimal', ask: true, decimals: stellen };
+    }
+    return { rule: 'piece', ask: false, decimals: 0 };
+}
+/** Wirksame Regel eines Artikels: gespeicherte Angabe schlaegt die Vorgabe der Einheit. */
+function quantityDefaults(a) {
+    const v = quantityRuleForUnit(a.unit);
+    return {
+        rule: a.quantityRule ?? v.rule,
+        ask: a.askQuantity ?? v.ask,
+        decimals: (a.quantityRule ?? v.rule) === 'decimal' ? Math.max(1, v.decimals || 2) : 0,
+    };
+}
+/** Deckelt eine gewuenschte Menge an der Hoechstmenge des Artikels (null = keine Grenze). */
+function allowedQuantity(a, wanted) {
+    return a.maxQuantity != null && a.maxQuantity > 0 ? Math.min(wanted, a.maxQuantity) : wanted;
+}
+function fromPosArticlePayload(p) {
+    return {
+        id: p.id ?? '',
+        name: p.name ?? '',
+        unitPriceCents: typeof p.unitPriceCents === 'number' ? p.unitPriceCents : null,
+        vatRate: typeof p.vatRate === 'number' ? p.vatRate : null,
+        unit: p.unit ?? '',
+        groupId: p.groupId ?? null,
+        revenueGroupId: typeof p.revenueGroupId === 'string' && p.revenueGroupId ? p.revenueGroupId : null,
+        visible: p.tile?.visible !== false,
+        sort: typeof p.tile?.sort === 'number' ? p.tile.sort : 0,
+        active: p.active !== false,
+        quantityRule: p.quantityRule === 'piece' || p.quantityRule === 'decimal' ? p.quantityRule : null,
+        askQuantity: typeof p.askQuantity === 'boolean' ? p.askQuantity : null,
+        maxQuantity: typeof p.maxQuantity === 'number' && Number.isFinite(p.maxQuantity) && p.maxQuantity > 0 ? p.maxQuantity : null,
+    };
+}
+function liste(daten, feld, name, lesen) {
+    const roh = daten?.[feld];
+    if (!Array.isArray(roh)) {
+        throw new errors_js_1.KasseneckValidationError(name, `Antwort enthaelt keine Liste (data.${feld} fehlt)`, 'response');
+    }
+    return roh.map((e) => lesen(typeof e === 'object' && e !== null ? e : {}));
+}
+async function listMyArticleGroups(transport) {
+    const daten = await transport('listMyArticleGroups');
+    return liste(daten, 'groups', 'listMyArticleGroups', (e) => fromArticleGroupPayload(e));
+}
+async function listMyArticles(transport) {
+    const daten = await transport('listMyArticles');
+    return liste(daten, 'articles', 'listMyArticles', (e) => fromPosArticlePayload(e));
+}

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

@@ -0,0 +1,27 @@
+import type { InternerTransport } from '../client/aufrufe.js';
+import { type PosSettings, type PosBusinessSettings, type PosDeviceSettings } from './settings.js';
+/** Einstellungen lesen: Standard + gespeichert (Backend: `getKasseSettings`). */
+export declare function getPosSettings(transport: InternerTransport, options?: {
+    deviceId?: string;
+}): Promise<PosSettings>;
+/** `{business, device}` einer Antwort, gemischt mit den Standardwerten. */
+export declare function posSettingsFromWire(data: {
+    business?: unknown;
+    device?: unknown;
+} | null | undefined): PosSettings;
+/** Betriebsweite Einstellungen schreiben (Recht `layout`); liefert den gemischten Stand. */
+export declare function setMyPosSettings(transport: InternerTransport, business: Partial<PosBusinessSettings>): Promise<PosBusinessSettings>;
+/** Geraete-Einstellungen schreiben (Recht `layout`); liefert den gemischten Stand. */
+export declare function setMyRegisterDeviceSettings(transport: InternerTransport, deviceId: string, device: Partial<PosDeviceSettings>): Promise<PosDeviceSettings>;
+/** Eingabe von [setMyPosLogo]: ein Bild als Data-URL (PNG, JPEG, SVG) oder das Entfernen. */
+export type SetMyPosLogoOptions = {
+    image: string;
+} | {
+    remove: true;
+};
+/**
+ * Bild-Logo der Kasse hochladen oder entfernen (Recht `layout`). Liefert die
+ * neue `logoImage`-Adresse, nach dem Entfernen `''`. Formatfehler meldet der
+ * Server als `logo_invalid_type`, `logo_too_large` oder `logo_invalid`.
+ */
+export declare function setMyPosLogo(transport: InternerTransport, options: SetMyPosLogoOptions): Promise<string>;

package/dist/cjs/pos/client.js

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPosSettings = getPosSettings;
+exports.posSettingsFromWire = posSettingsFromWire;
+exports.setMyPosSettings = setMyPosSettings;
+exports.setMyRegisterDeviceSettings = setMyRegisterDeviceSettings;
+exports.setMyPosLogo = setMyPosLogo;
+const errors_js_1 = require("../client/errors.js");
+const settings_js_1 = require("./settings.js");
+/*
+ * Die Einstellungs-Aufrufe am Draht `/api/v3`: Parameter und Antwort heissen
+ * `business`/`device`, Schluessel und Werte englisch (Nachtrag §11.7.2).
+ *
+ * **Nur geaenderte Felder senden** ([posSettingsChanges]), nie den ganzen
+ * gemischten Block: der Server mischt tief, ein nicht geaenderter Wert, den
+ * dieses Paket nicht kennt (`theme: 'sepia'`), bleibt so am Server stehen.
+ * Gelesen wird er unveraendert ([unknownPosSettingValues] nennt ihn).
+ *
+ * Vor dem Senden prueft dieser Weg nur die gesendeten Felder (ein Feld mit
+ * `undefined` geht nicht hinaus und wird nicht geprueft), und nur, was der
+ * Server sicher abweist: einen
+ * Schluessel, den es nicht gibt (auch einen deutschen aus 0.x wie `stil`),
+ * einen Wert ausserhalb der Wertemenge des Feldes (`'nacht'`), eine
+ * Steuersatz-Karte ohne einen Satz an und eine unbekannte Tasten-Aktion.
+ * Der Fehler nennt den aeusseren Pfad wie das Backend (`business.theme`).
+ * Alles Weitere (Bereiche, Chips, Farbformat) entscheidet der Server und
+ * meldet es als `validation` mit `data.errors[].field`.
+ */
+/** Einstellungen lesen: Standard + gespeichert (Backend: `getKasseSettings`). */
+async function getPosSettings(transport, options = {}) {
+    const params = {};
+    if (options.deviceId)
+        params.deviceId = options.deviceId;
+    const daten = await transport('getKasseSettings', params);
+    return posSettingsFromWire(daten);
+}
+/** `{business, device}` einer Antwort, gemischt mit den Standardwerten. */
+function posSettingsFromWire(data) {
+    return {
+        business: (0, settings_js_1.mergePosSettings)(settings_js_1.POS_BUSINESS_DEFAULTS, objekt(data?.business)),
+        device: (0, settings_js_1.mergePosSettings)(settings_js_1.POS_DEVICE_DEFAULTS, objekt(data?.device)),
+    };
+}
+/** Betriebsweite Einstellungen schreiben (Recht `layout`); liefert den gemischten Stand. */
+async function setMyPosSettings(transport, business) {
+    const name = 'setMyKasseSettings';
+    pruefeTeil(name, 'business', business, settings_js_1.POS_BUSINESS_DEFAULTS, settings_js_1.POS_BUSINESS_VALUES);
+    const saetze = eigenerWert(business, 'vatRates');
+    if (saetze !== undefined) {
+        const karte = objekt(saetze);
+        // Unter /v3 prueft der Server die uebergebene Karte fuer sich: ein
+        // einzelner Schalter wie {20: false} waere dort "kein Satz an".
+        if (!karte || !Object.values(karte).some((an) => an === true)) {
+            throw new errors_js_1.KasseneckValidationError(name, 'business.vatRates: mindestens ein Steuersatz muss an sein (immer die ganze Karte senden)', 'request');
+        }
+    }
+    const daten = await transport(name, { business });
+    return (0, settings_js_1.mergePosSettings)(settings_js_1.POS_BUSINESS_DEFAULTS, objekt(daten?.business));
+}
+/** Geraete-Einstellungen schreiben (Recht `layout`); liefert den gemischten Stand. */
+async function setMyRegisterDeviceSettings(transport, deviceId, device) {
+    const name = 'setMyRegisterDeviceSettings';
+    if (typeof deviceId !== 'string' || deviceId.trim() === '') {
+        throw new errors_js_1.KasseneckValidationError(name, 'deviceId fehlt', 'request');
+    }
+    pruefeTeil(name, 'device', device, settings_js_1.POS_DEVICE_DEFAULTS, settings_js_1.POS_DEVICE_VALUES);
+    const tasten = eigenerWert(device, 'shortcuts');
+    if (tasten !== undefined) {
+        const karte = objekt(tasten);
+        if (!karte)
+            throw new errors_js_1.KasseneckValidationError(name, 'device.shortcuts: keine Tastenkarte', 'request');
+        const aktionen = new Set(settings_js_1.POS_SHORTCUT_ACTIONS);
+        for (const aktion of Object.keys(karte)) {
+            if (karte[aktion] === undefined)
+                continue;
+            if (!aktionen.has(aktion)) {
+                throw new errors_js_1.KasseneckValidationError(name, `device.shortcuts.${aktion}: unbekannte Aktion`, 'request');
+            }
+        }
+        // Doppelbelegung innerhalb der gesendeten Karte; posSettingsChanges sendet
+        // bei jeder Tastenaenderung die ganze Karte, so ist das die ganze Belegung.
+        const konflikt = (0, settings_js_1.posShortcutConflict)(karte);
+        if (konflikt) {
+            throw new errors_js_1.KasseneckValidationError(name, `device.shortcuts.${konflikt.action}: Taste ${konflikt.key} schon belegt (${konflikt.heldBy})`, 'request');
+        }
+    }
+    const daten = await transport(name, { deviceId, device });
+    return (0, settings_js_1.mergePosSettings)(settings_js_1.POS_DEVICE_DEFAULTS, objekt(daten?.device));
+}
+/**
+ * Bild-Logo der Kasse hochladen oder entfernen (Recht `layout`). Liefert die
+ * neue `logoImage`-Adresse, nach dem Entfernen `''`. Formatfehler meldet der
+ * Server als `logo_invalid_type`, `logo_too_large` oder `logo_invalid`.
+ */
+async function setMyPosLogo(transport, options) {
+    const name = 'setMyKasseLogo';
+    const params = {};
+    if ('remove' in options && options.remove === true) {
+        params.remove = true;
+    }
+    else if ('image' in options && typeof options.image === 'string' && options.image !== '') {
+        params.image = options.image;
+    }
+    else {
+        throw new errors_js_1.KasseneckValidationError(name, 'image fehlt (oder remove: true)', 'request');
+    }
+    const daten = await transport(name, params);
+    const bild = daten?.logoImage;
+    if (typeof bild !== 'string') {
+        throw new errors_js_1.KasseneckValidationError(name, 'Antwort enthaelt kein Feld "logoImage"', 'response');
+    }
+    return bild;
+}
+/** Eigene Eigenschaft oder `undefined`, nie eine geerbte (`constructor`, `toString`). */
+function eigenerWert(block, k) {
+    return Object.prototype.hasOwnProperty.call(block, k) ? block[k] : undefined;
+}
+function objekt(wert) {
+    return wert !== null && typeof wert === 'object' && !Array.isArray(wert) ? wert : null;
+}
+function pruefeTeil(name, teil, block, standard, werte) {
+    const karte = objekt(block);
+    // Ein Feld mit `undefined` sendet JSON gar nicht: es zaehlt weder als
+    // Einstellung noch wird es geprueft.
+    const gesendet = karte ? Object.entries(karte).filter(([, wert]) => wert !== undefined) : [];
+    if (gesendet.length === 0) {
+        throw new errors_js_1.KasseneckValidationError(name, `${teil}: keine Einstellungen uebergeben`, 'request');
+    }
+    for (const [schluessel, wert] of gesendet) {
+        if (!Object.prototype.hasOwnProperty.call(standard, schluessel)) {
+            throw new errors_js_1.KasseneckValidationError(name, `${teil}.${schluessel}: unbekanntes Feld`, 'request');
+        }
+        const erlaubt = Object.prototype.hasOwnProperty.call(werte, schluessel) ? werte[schluessel] : undefined;
+        if (erlaubt && !erlaubt.includes(wert)) {
+            // Kein Altwert: dann ein Wert, den der Server kennt und dieses Paket
+            // nicht. Er kam beim Lesen herein; wer den ganzen Block zurueckschickt,
+            // braucht den Hinweis auf den richtigen Weg.
+            const hinweis = (0, settings_js_1._istAltwert0x)(schluessel, wert)
+                ? 'ungueltiger Wert (innere Form 0.x)'
+                : 'ungueltiger Wert (vom Server unbekannt? nur geaenderte Felder senden: posSettingsChanges)';
+            throw new errors_js_1.KasseneckValidationError(name, `${teil}.${schluessel}: ${hinweis}`, 'request');
+        }
+    }
+}

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

@@ -0,0 +1,86 @@
+import type { InternerTransport } from '../client/aufrufe.js';
+import type { ReceiptLayout } from '../receipt/layout.js';
+import type { PrintLogo } from '../receipt/layout-escpos.js';
+/**
+ * Netzwerk-Bondrucker ueber Epson "Server Direct Print": das Backend fuehrt
+ * je Konto Drucker mit einer geheimen Abhol-URL; die Kasse legt Druckjobs
+ * aus einem Zeilenmodell an, der Drucker holt sie selbst ab (alle paar
+ * Sekunden) und meldet das Ergebnis. So druckt jeder Browser -- ohne lokale
+ * Software. Das ePOS-XML baut das Backend aus dem Zeichenraster (ein Setzweg).
+ */
+export interface NetworkPrinter {
+    id: string;
+    name: string;
+    /** Art des Druckers; heute nur `epson-sdp`. */
+    kind: string;
+    paperSize: 'mm58' | 'mm80';
+    active: boolean;
+    createdAt: number | null;
+    /** Letzter Abruf des Druckers (ms); null = noch nie verbunden. */
+    lastSeenAt: number | null;
+    lastResult: {
+        success: boolean;
+        code: string | null;
+        at: number;
+    } | null;
+    /** Kennung, die der Drucker selbst schickt (Feld ID im Drucker-Menue). */
+    printerSerial: string | null;
+    /** Abhol-URL fuer das Drucker-Menue, nur fuer den Chef bzw. das Konto. */
+    sdpUrl?: string;
+}
+/** Stand eines Druckjobs (Katalog `DRUCKJOB`). */
+export declare const PRINT_JOB_STATUSES: readonly ["pending", "sent", "printed", "failed", "expired"];
+/**
+ * Stand eines Druckjobs; `'unknown'` = der Server nannte einen Stand, den dieses
+ * Paket nicht kennt (oder keinen). Er gilt als Ende der Abfrage (siehe
+ * [isPrintJobFinished]): nie als gedruckt, aber auch kein Abfragen bis zum
+ * Zeitlimit.
+ */
+export type PrintJobStatus = typeof PRINT_JOB_STATUSES[number] | 'unknown';
+/** Endet die Abfrage bei diesem Stand? `printed`, `failed`, `expired` und `unknown`. */
+export declare function isPrintJobFinished(status: PrintJobStatus): boolean;
+/**
+ * Bekannte Werte fuer `source` (Katalog `DRUCK_QUELLE`): die Kasse oder das
+ * Panel. Der Server nimmt Freitext bis 40 Zeichen an und uebersetzt nur diese
+ * beiden.
+ */
+export declare const PRINT_JOB_SOURCES: readonly ["pos", "panel"];
+export type PrintJobSource = typeof PRINT_JOB_SOURCES[number] | (string & {});
+export interface PrintJob {
+    jobId: string;
+    status: PrintJobStatus;
+    createdAt?: number | null;
+    sentAt?: number | null;
+    result: {
+        success: boolean;
+        code: string | null;
+        status?: string | null;
+        at?: number;
+    } | null;
+}
+export declare function listMyPrinters(transport: InternerTransport): Promise<NetworkPrinter[]>;
+export interface CreatePrintJobOptions {
+    printerId: string;
+    layout: ReceiptLayout;
+    receiptId?: string;
+    title?: string;
+    source?: PrintJobSource;
+    /** Firmenlogo als fertiges Rasterbild (`rasterizeLogo`); der Server dekodiert keine Bilder. */
+    logo?: PrintLogo | null;
+    /**
+     * Das Kasseneck-Logo am Ende (Konto-Flag `kreiseck_logo`). Heisst wie bei
+     * den Druckwegen (`escPosLayoutBytes`, `eposPrintXml`, `receiptSheet`), damit
+     * dieselben Optionen ueberall wirken; am Draht heisst der Wert `brand`.
+     */
+    brandMark?: boolean;
+}
+export declare function createPrintJob(transport: InternerTransport, o: CreatePrintJobOptions): Promise<PrintJob>;
+/**
+ * Stand eines Druckjobs abfragen. Der Aufrufer fragt, bis [isPrintJobFinished]
+ * wahr ist, und begrenzt die Abfrage trotzdem selbst (Anzahl oder Zeit): ein
+ * Drucker, der nie abholt, bleibt `pending`.
+ */
+export declare function getPrintJob(transport: InternerTransport, o: {
+    printerId: string;
+    jobId: string;
+}): Promise<PrintJob>;

package/dist/cjs/pos/drucker.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PRINT_JOB_SOURCES = exports.PRINT_JOB_STATUSES = void 0;
+exports.isPrintJobFinished = isPrintJobFinished;
+exports.listMyPrinters = listMyPrinters;
+exports.createPrintJob = createPrintJob;
+exports.getPrintJob = getPrintJob;
+const index_js_1 = require("../printing/index.js");
+/** Stand eines Druckjobs (Katalog `DRUCKJOB`). */
+exports.PRINT_JOB_STATUSES = ['pending', 'sent', 'printed', 'failed', 'expired'];
+/** Endet die Abfrage bei diesem Stand? `printed`, `failed`, `expired` und `unknown`. */
+function isPrintJobFinished(status) {
+    return status === 'printed' || status === 'failed' || status === 'expired' || status === 'unknown';
+}
+/**
+ * Bekannte Werte fuer `source` (Katalog `DRUCK_QUELLE`): die Kasse oder das
+ * Panel. Der Server nimmt Freitext bis 40 Zeichen an und uebersetzt nur diese
+ * beiden.
+ */
+exports.PRINT_JOB_SOURCES = ['pos', 'panel'];
+const text = (v) => (typeof v === 'string' && v ? v : null);
+const zahl = (v) => (typeof v === 'number' && Number.isFinite(v) ? v : null);
+const STATUS = new Set(exports.PRINT_JOB_STATUSES);
+/**
+ * Stand eines Jobs aus der Antwort. Ein Wert ausserhalb des Katalogs (ein
+ * kuenftiger Endstand wie `cancelled`) oder gar keiner wird `'unknown'`:
+ * sichtbar, nie als gedruckt gewertet, und die Abfrage endet.
+ */
+function status(v) {
+    return typeof v === 'string' && STATUS.has(v) ? v : 'unknown';
+}
+async function listMyPrinters(transport) {
+    const daten = await transport('listMyPrinters', {});
+    return (Array.isArray(daten?.printers) ? daten.printers : []).map((r) => {
+        const d = (r ?? {});
+        const e = d.lastResult && typeof d.lastResult === 'object' ? d.lastResult : null;
+        return {
+            id: String(d.id ?? ''), name: String(d.name ?? ''), kind: String(d.kind ?? 'epson-sdp'), paperSize: d.paperSize === 'mm58' ? 'mm58' : 'mm80',
+            active: d.active !== false, createdAt: zahl(d.createdAt), lastSeenAt: zahl(d.lastSeenAt),
+            lastResult: e ? { success: e.success === true, code: text(e.code), at: zahl(e.at) ?? 0 } : null,
+            printerSerial: text(d.printerSerial),
+            ...(text(d.sdpUrl) ? { sdpUrl: String(d.sdpUrl) } : {}),
+        };
+    });
+}
+async function createPrintJob(transport, o) {
+    const params = { printerId: o.printerId, layout: o.layout };
+    if (o.receiptId)
+        params.receiptId = o.receiptId;
+    if (o.title)
+        params.title = o.title;
+    if (o.source)
+        params.source = o.source;
+    if (o.logo) {
+        params.logo = {
+            scale: o.logo.size, pxWidth: o.logo.pixelWidth, pxHeight: o.logo.pixelHeight,
+            width: o.logo.raster.width, height: o.logo.raster.height, rows: (0, index_js_1.rasterRowsBase64)(o.logo.raster),
+        };
+    }
+    if (o.brandMark === true)
+        params.brand = true;
+    const daten = await transport('createPrintJob', params);
+    return { jobId: String(daten?.jobId ?? ''), status: status(daten?.status), result: null };
+}
+/**
+ * Stand eines Druckjobs abfragen. Der Aufrufer fragt, bis [isPrintJobFinished]
+ * wahr ist, und begrenzt die Abfrage trotzdem selbst (Anzahl oder Zeit): ein
+ * Drucker, der nie abholt, bleibt `pending`.
+ */
+async function getPrintJob(transport, o) {
+    const d = await transport('getPrintJob', { printerId: o.printerId, jobId: o.jobId });
+    const e = d?.result && typeof d.result === 'object' ? d.result : null;
+    return {
+        jobId: String(d?.jobId ?? o.jobId), status: status(d?.status),
+        createdAt: zahl(d?.createdAt), sentAt: zahl(d?.sentAt),
+        result: e ? { success: e.success === true, code: text(e.code), status: text(e.status), at: zahl(e.at) ?? undefined } : null,
+    };
+}

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

@@ -0,0 +1,36 @@
+import { KasseneckApiError } from '../client/errors.js';
+/**
+ * Fehler der Kassen-Aufrufe um den Verkauf herum (Einstellungen, Logo,
+ * Artikel, Drucker, Trinkgeld-Empfaenger) auswerten: am `code`, nie am Text.
+ * Belege, Storno und Belegmail haben eigene Listen (`RECEIPT_ERROR_CODES`,
+ * `CANCELLATION_ERROR_CODES`, `RECEIPT_EMAIL_ERROR_CODES`), die Anmeldung
+ * `REGISTER_ERROR_CODES` im Unterpfad `./register`.
+ *
+ * Abgeleitet aus dem Vertrags-Export (Fehlerfaelle dieser zehn Endpunkte in
+ * `fixtures/v3/antworten/kasse.json` und ihre Handler-Codes); ein Test haelt
+ * die Liste deckungsgleich. `validation` traegt `data.errors[]` mit dem
+ * aeusseren Feldpfad (`business.theme`, `device.shortcuts.splitPayment`).
+ * Dazu kommen die Codes, die der Rand auf jedem Kassen-Endpunkt erzeugen kann:
+ * die Anmelde- und Pruefcodes (`errorCodes.auth` ohne die sieben des
+ * Partner-Zugangs, z. B. `register_user_not_found`, wenn der Chef einen
+ * angemeldeten Benutzer loescht) und die des Rands selbst (`errorCodes.edge`:
+ * `validation`, `not_found`, `internal_translation_error`, `dialect_mismatch`,
+ * `response_translation_failed`). Ein Code, der in keiner Liste steht, bleibt
+ * ueber `KasseneckApiError.code` lesbar; die Kasse braucht dafuer einen
+ * Rueckfallzweig.
+ */
+export declare const POS_ERROR_CODES: readonly ["account_not_found", "admin_required", "cashregister_not_assigned", "cashregister_not_found", "cashregister_token_invalid", "cashregister_token_missing", "device_not_found", "dialect_mismatch", "internal_translation_error", "live_not_enabled", "logo_invalid", "logo_invalid_type", "logo_too_large", "method_not_allowed", "mfa_required", "module_inactive", "not_found", "not_permitted", "print_job_not_found", "print_layout_failed", "printer_not_found", "register_user_no_business", "register_user_not_allowed", "register_user_not_found", "response_translation_failed", "session_expired", "session_other_cashregister", "unauthorized", "user_disabled", "user_verification_failed", "validation", "route_missing"];
+export type PosErrorCode = typeof POS_ERROR_CODES[number];
+export declare function isPosErrorCode(value: unknown): value is PosErrorCode;
+/** Der Code eines geworfenen Fehlers, wenn er in [POS_ERROR_CODES] steht; sonst `undefined`. */
+export declare function posErrorCode(error: unknown): PosErrorCode | undefined;
+/** Kurzform fuer `catch (e) { if (isPosError(e, 'logo_too_large')) … }`. */
+export declare function isPosError(error: unknown, code?: PosErrorCode): error is KasseneckApiError;
+/** Ein Feldfehler aus `data.errors[]` einer `validation`-Antwort. */
+export interface PosFieldError {
+    /** Aeusserer Feldpfad, z. B. `business.vatRates` oder `device.shortcuts.cash`. */
+    field: string;
+    message: string;
+}
+/** Die Feldfehler einer `validation`-Antwort; leer, wenn es keine sind. */
+export declare function posFieldErrors(error: unknown): PosFieldError[];

package/dist/cjs/pos/errors.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.POS_ERROR_CODES = void 0;
+exports.isPosErrorCode = isPosErrorCode;
+exports.posErrorCode = posErrorCode;
+exports.isPosError = isPosError;
+exports.posFieldErrors = posFieldErrors;
+const errors_js_1 = require("../client/errors.js");
+/**
+ * Fehler der Kassen-Aufrufe um den Verkauf herum (Einstellungen, Logo,
+ * Artikel, Drucker, Trinkgeld-Empfaenger) auswerten: am `code`, nie am Text.
+ * Belege, Storno und Belegmail haben eigene Listen (`RECEIPT_ERROR_CODES`,
+ * `CANCELLATION_ERROR_CODES`, `RECEIPT_EMAIL_ERROR_CODES`), die Anmeldung
+ * `REGISTER_ERROR_CODES` im Unterpfad `./register`.
+ *
+ * Abgeleitet aus dem Vertrags-Export (Fehlerfaelle dieser zehn Endpunkte in
+ * `fixtures/v3/antworten/kasse.json` und ihre Handler-Codes); ein Test haelt
+ * die Liste deckungsgleich. `validation` traegt `data.errors[]` mit dem
+ * aeusseren Feldpfad (`business.theme`, `device.shortcuts.splitPayment`).
+ * Dazu kommen die Codes, die der Rand auf jedem Kassen-Endpunkt erzeugen kann:
+ * die Anmelde- und Pruefcodes (`errorCodes.auth` ohne die sieben des
+ * Partner-Zugangs, z. B. `register_user_not_found`, wenn der Chef einen
+ * angemeldeten Benutzer loescht) und die des Rands selbst (`errorCodes.edge`:
+ * `validation`, `not_found`, `internal_translation_error`, `dialect_mismatch`,
+ * `response_translation_failed`). Ein Code, der in keiner Liste steht, bleibt
+ * ueber `KasseneckApiError.code` lesbar; die Kasse braucht dafuer einen
+ * Rueckfallzweig.
+ */
+exports.POS_ERROR_CODES = Object.freeze([
+    'account_not_found',
+    'admin_required',
+    'cashregister_not_assigned',
+    'cashregister_not_found',
+    'cashregister_token_invalid',
+    'cashregister_token_missing',
+    'device_not_found',
+    'dialect_mismatch',
+    'internal_translation_error',
+    'live_not_enabled',
+    'logo_invalid',
+    'logo_invalid_type',
+    'logo_too_large',
+    'method_not_allowed',
+    'mfa_required',
+    'module_inactive',
+    'not_found',
+    'not_permitted',
+    'print_job_not_found',
+    'print_layout_failed',
+    'printer_not_found',
+    'register_user_no_business',
+    'register_user_not_allowed',
+    'register_user_not_found',
+    'response_translation_failed',
+    'session_expired',
+    'session_other_cashregister',
+    'unauthorized',
+    'user_disabled',
+    'user_verification_failed',
+    'validation',
+    // Code des Pakets (CLIENT_ERROR_CODES): HTML statt Backend, der Aufruf kam nie an
+    'route_missing',
+]);
+const BEKANNT = new Set(exports.POS_ERROR_CODES);
+function isPosErrorCode(value) {
+    return typeof value === 'string' && BEKANNT.has(value);
+}
+/** Der Code eines geworfenen Fehlers, wenn er in [POS_ERROR_CODES] steht; sonst `undefined`. */
+function posErrorCode(error) {
+    if (!(error instanceof errors_js_1.KasseneckApiError))
+        return undefined;
+    return isPosErrorCode(error.code) ? error.code : undefined;
+}
+/** Kurzform fuer `catch (e) { if (isPosError(e, 'logo_too_large')) … }`. */
+function isPosError(error, code) {
+    const gefunden = posErrorCode(error);
+    return gefunden !== undefined && (code === undefined || gefunden === code);
+}
+/** Die Feldfehler einer `validation`-Antwort; leer, wenn es keine sind. */
+function posFieldErrors(error) {
+    if (!(error instanceof errors_js_1.KasseneckApiError))
+        return [];
+    const roh = error.details['errors'];
+    if (!Array.isArray(roh))
+        return [];
+    const raus = [];
+    for (const eintrag of roh) {
+        if (eintrag === null || typeof eintrag !== 'object')
+            continue;
+        const { field, message } = eintrag;
+        if (typeof field === 'string' && typeof message === 'string')
+            raus.push({ field, message });
+    }
+    return raus;
+}