@kreiseck/kasseneck-api 0.6.7

package/dist/esm/models/cancellation.d.ts

@@ -0,0 +1,51 @@
+import type { Receipt } from './receipt.js';
+/**
+ * Storno-Metadaten — Zwilling von `functions/storno-core.js`.
+ *
+ * Ein Storno ist ein eigener, signierter Beleg vom Typ `cancellation` mit
+ * negativen Betraegen. Was NICHT signiert ist und hier als Metadaten laeuft:
+ * der Bezug zum Original (`cancellationOf`, `cancellationReason` am
+ * Storno-Beleg) und die Liste der Stornos am Original (`cancellations`), aus
+ * der sich die Restmengen ergeben.
+ */
+/** Grund-Katalog: Codes wie im Backend, Anzeigetext fuer Bon und Bedienung. */
+export declare const CANCELLATION_REASONS: Readonly<{
+    readonly fehleingabe: "Fehleingabe";
+    readonly kunde_storniert: "Kunde hat storniert";
+    readonly falsche_zahlart: "Falsche Zahlart";
+    readonly doppelt_erfasst: "Doppelt erfasst";
+    readonly sonstiges: "Sonstiges";
+}>;
+export type CancellationReason = keyof typeof CANCELLATION_REASONS;
+export declare function isCancellationReason(value: unknown): value is CancellationReason;
+/** Bezug eines Storno-Belegs auf sein Original. */
+export interface CancellationOf {
+    receiptId: string;
+    fullReceiptId: string | null;
+}
+/** Eine stornierte Position: Index im Original und Menge. */
+export interface CancellationItem {
+    index: number;
+    quantity: number;
+}
+/**
+ * Eintrag in `cancellations[]` am Original. `pending` = Reservierung, die
+ * das Backend vor der Buchung setzt und danach ersetzt; sie zaehlt fuer die
+ * Restmengen nur, solange sie frisch ist (siehe [remainingQuantities]).
+ */
+export interface Cancellation {
+    receiptId?: string;
+    pending?: boolean;
+    at: number;
+    by: string | null;
+    note: string | null;
+    items: CancellationItem[];
+}
+/** Ab wann eine liegengebliebene Reservierung nicht mehr zaehlt (wie im Backend). */
+export declare const CANCELLATION_RESERVATION_MS = 120000;
+/**
+ * Restmenge je Position eines Belegs — Belegmenge minus alles, was storniert
+ * oder frisch reserviert ist; nie unter null. Fuer den Storno-Dialog der Kasse
+ * (Reste anzeigen, bevor der Server gefragt wird). Die Wahrheit hat der Server.
+ */
+export declare function remainingQuantities(receipt: Receipt, nowMs?: number): number[];

package/dist/esm/models/cancellation.js

@@ -0,0 +1,40 @@
+/**
+ * Storno-Metadaten — Zwilling von `functions/storno-core.js`.
+ *
+ * Ein Storno ist ein eigener, signierter Beleg vom Typ `cancellation` mit
+ * negativen Betraegen. Was NICHT signiert ist und hier als Metadaten laeuft:
+ * der Bezug zum Original (`cancellationOf`, `cancellationReason` am
+ * Storno-Beleg) und die Liste der Stornos am Original (`cancellations`), aus
+ * der sich die Restmengen ergeben.
+ */
+/** Grund-Katalog: Codes wie im Backend, Anzeigetext fuer Bon und Bedienung. */
+export const CANCELLATION_REASONS = Object.freeze({
+    fehleingabe: 'Fehleingabe',
+    kunde_storniert: 'Kunde hat storniert',
+    falsche_zahlart: 'Falsche Zahlart',
+    doppelt_erfasst: 'Doppelt erfasst',
+    sonstiges: 'Sonstiges',
+});
+export function isCancellationReason(value) {
+    return typeof value === 'string' && Object.prototype.hasOwnProperty.call(CANCELLATION_REASONS, value);
+}
+/** Ab wann eine liegengebliebene Reservierung nicht mehr zaehlt (wie im Backend). */
+export const CANCELLATION_RESERVATION_MS = 120_000;
+/**
+ * Restmenge je Position eines Belegs — Belegmenge minus alles, was storniert
+ * oder frisch reserviert ist; nie unter null. Fuer den Storno-Dialog der Kasse
+ * (Reste anzeigen, bevor der Server gefragt wird). Die Wahrheit hat der Server.
+ */
+export function remainingQuantities(receipt, nowMs = Date.now()) {
+    const rest = receipt.items.map((item) => item.quantity);
+    for (const eintrag of receipt.cancellations ?? []) {
+        if (eintrag.pending === true && eintrag.at < nowMs - CANCELLATION_RESERVATION_MS)
+            continue;
+        for (const pos of eintrag.items) {
+            if (Number.isInteger(pos.index) && pos.index >= 0 && pos.index < rest.length) {
+                rest[pos.index] = Math.max(0, (rest[pos.index] ?? 0) - pos.quantity);
+            }
+        }
+    }
+    return rest;
+}

package/dist/esm/models/cashregister.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Kasse — die Antwortform von `listMyCashregisters` (functions/index.js).
+ *
+ * Das Dart-Vorbild (`Cashregister` in kasseneck_api/lib/models/cashregister.dart)
+ * liest das **Firestore-Dokument** direkt ueber das `cloud_firestore`-SDK und
+ * kommt deshalb an `token` und `aes_key`. Dieses Paket spricht das Backend
+ * ausschliesslich ueber die HTTPS-Endpunkte, und die geben beides nicht her:
+ *
+ * - **`aes_key` steht in dieser Antwort ueberhaupt nicht** (nur im
+ *   Admin-Export). Ein Feld dafuer versprach hier einen `string` und lieferte
+ *   `undefined` — deshalb gibt es keines mehr.
+ * - **`token` ist fuer Kassen-Benutzer bewusst `null`**: im Browser traegt die
+ *   Sitzung die Identitaet, und ein einmal ausgelieferter Kassen-Token liesse
+ *   sich ohne Sitzung und ohne PIN weiterverwenden (so steht es im Backend an
+ *   der Stelle selbst).
+ *
+ * `create_time` kommt aus `isoTs(...)` und ist **`null`**, wenn das Dokument
+ * keinen Zeitstempel traegt. Aus `null` wird hier kein Zeitpunkt: `new Date(null)`
+ * ergaebe still den 1.1.1970, und ein erfundenes Datum ist schlechter als ein
+ * fehlendes.
+ *
+ * Aus demselben Grund fehlt `userId`: das Dart-Vorbild traegt es, weil es den
+ * Firestore-**Pfad** kennt (`users/{uid}/cashregisters/{id}`). In dieser
+ * Antwort steht es nicht, und ein Kassen-Benutzer erfaehrt die Kennung seines
+ * Betriebs bewusst nie — sie steckt allein im Token.
+ */
+export interface Cashregister {
+    id: string;
+    /** Anzeigename der Kasse, sofern gepflegt. */
+    label?: string;
+    /** Freie Beschreibung, sofern gepflegt. */
+    description?: string;
+    /** Anlagezeitpunkt; fehlt, wenn die Antwort keinen lesbaren traegt. */
+    createTime?: Date;
+    /** Kassen-Token; fuer Kassen-Benutzer nie enthalten (siehe Klassenkommentar). */
+    token?: string;
+    /** Zugeordnete Signatureinheit. */
+    signatureId?: string;
+    onboarding: CashregisterOnboarding;
+}
+/**
+ * Stand der Inbetriebnahme (RKSV): Kasse bei FinanzOnline registriert,
+ * Startbeleg erzeugt, Startbeleg uebermittelt. Die drei Kennzeichen entscheiden
+ * in der Browser-Kasse, ob ueberhaupt schon kassiert werden darf.
+ */
+export interface CashregisterOnboarding {
+    cashboxRegistered: boolean;
+    startbelegCreated: boolean;
+    startbelegTransmitted: boolean;
+    cashboxRegisteredAt?: Date;
+    startbelegCreatedAt?: Date;
+    startbelegTransmittedAt?: Date;
+}
+/** Nutzlast-Form, die dieses Paket liest — die Feldnamen von `listMyCashregisters`. */
+export interface CashregisterPayload {
+    id?: string | null;
+    label?: string | null;
+    description?: string | null;
+    create_time?: string | null;
+    signature_id?: string | null;
+    token?: string | null;
+    onboarding?: CashregisterOnboardingPayload | null;
+}
+export interface CashregisterOnboardingPayload {
+    cashbox_registered?: boolean | null;
+    startbeleg_created?: boolean | null;
+    startbeleg_transmitted?: boolean | null;
+    cashbox_registered_at?: string | null;
+    startbeleg_created_at?: string | null;
+    startbeleg_transmitted_at?: string | null;
+}
+/**
+ * Liest eine Kasse aus der Antwort. `id` gewinnt aus der Nutzlast, faellt aber
+ * auf den uebergebenen Wert zurueck — die Liste fuehrt die Dokument-ID mit,
+ * ein einzeln gelesenes Dokument nicht.
+ */
+export declare function fromCashregisterPayload(payload: CashregisterPayload, id: string): Cashregister;

package/dist/esm/models/cashregister.js

@@ -0,0 +1,50 @@
+import { parseServerTimeStamp } from '../vienna-time.js';
+/**
+ * Liest eine Kasse aus der Antwort. `id` gewinnt aus der Nutzlast, faellt aber
+ * auf den uebergebenen Wert zurueck — die Liste fuehrt die Dokument-ID mit,
+ * ein einzeln gelesenes Dokument nicht.
+ */
+export function fromCashregisterPayload(payload, id) {
+    const ob = payload.onboarding ?? {};
+    return {
+        id: payload.id ?? id,
+        ...(payload.label ? { label: payload.label } : {}),
+        ...(payload.description ? { description: payload.description } : {}),
+        ...zeitfeld('createTime', payload.create_time),
+        ...(payload.token ? { token: payload.token } : {}),
+        ...(payload.signature_id ? { signatureId: payload.signature_id } : {}),
+        onboarding: {
+            cashboxRegistered: ob.cashbox_registered === true,
+            startbelegCreated: ob.startbeleg_created === true,
+            startbelegTransmitted: ob.startbeleg_transmitted === true,
+            ...zeitfeld('cashboxRegisteredAt', ob.cashbox_registered_at),
+            ...zeitfeld('startbelegCreatedAt', ob.startbeleg_created_at),
+            ...zeitfeld('startbelegTransmittedAt', ob.startbeleg_transmitted_at),
+        },
+    };
+}
+/**
+ * Ein Zeitfeld, das es nur gibt, wenn die Nutzlast einen lesbaren Zeitstempel
+ * traegt. `null` (der Normalfall aus `isoTs`) und unlesbarer Unsinn ergeben
+ * **kein** Feld statt eines erfundenen Zeitpunkts — die Kassenliste soll sich
+ * auch dann anzeigen lassen, wenn ein einzelner Eintrag ein kaputtes Datum
+ * fuehrt (dieselbe tolerante Leserichtung wie beim Enum-Lesen).
+ */
+function zeitfeld(name, roh) {
+    const wert = zeitpunkt(roh);
+    return (wert === undefined ? {} : { [name]: wert });
+}
+function zeitpunkt(roh) {
+    if (typeof roh !== 'string' || roh.trim() === '') {
+        return undefined;
+    }
+    try {
+        // Ueber parseServerTimeStamp und nie ueber `new Date(text)`: ein
+        // offsetloser Zeitstempel waere sonst die lokale Zeit des ausfuehrenden
+        // Rechners (siehe ../vienna-time.ts).
+        return parseServerTimeStamp(roh);
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/esm/models/enum-payload.d.ts

@@ -0,0 +1,26 @@
+import { VatRate } from '../enums/index.js';
+/**
+ * Loest einen Enum-Eintrag anhand seines Nutzlast-Schluessels auf (z. B.
+ * `receiptType: 'standard'` — bei den mit `defineEnum()` gebauten Enums ist
+ * der Objekt-Schluessel selbst die Nutzlast).
+ *
+ * Nur fuer den **Schreibpfad**: bevor dieses Paket selbst einen Wert nach
+ * aussen traegt, muss er bekannt sein — ein unbekannter Schluessel wirft.
+ * Fuer den Lesepfad (Daten, die vom Backend hereinkommen) siehe
+ * [readEnumKey]: dort darf ein einzelner unbekannter Wert nicht die ganze
+ * Belegliste zum Absturz bringen.
+ */
+export declare function requireEnumKey<T extends Record<string, unknown>>(enumObj: T, key: string, label: string): T[keyof T];
+/**
+ * Lesepfad-Pendant zu [requireEnumKey]: ein unbekannter Schluessel (z. B. ein
+ * neuer Belegtyp oder eine neue Zahlungsart, die dieses Paket noch nicht
+ * kennt) wirft nicht und wird auch nicht still zu `undefined` — der rohe
+ * Nutzlast-Schluessel bleibt als String erhalten. Ein Aufrufer, der eine
+ * Belegliste anzeigt, kann so alle Positionen weiterlesen; nur die unbekannte
+ * bleibt (erkennbar) unaufgeloest.
+ */
+export declare function readEnumKey<T extends Record<string, unknown>>(enumObj: T, key: string): T[keyof T] | string;
+/** Schreibpfad: loest einen Steuersatz anhand seines `rate`-Werts auf, wirft bei unbekanntem Satz. */
+export declare function requireVatRateByRate(rate: number): VatRate;
+/** Lesepfad: unbekannter Satz bleibt als roher `rate`-Wert erhalten statt zu werfen oder `undefined` zu werden. */
+export declare function readVatRateByRate(rate: number): VatRate | number;

package/dist/esm/models/enum-payload.js

@@ -0,0 +1,44 @@
+import { VatRate } from '../enums/index.js';
+/**
+ * Loest einen Enum-Eintrag anhand seines Nutzlast-Schluessels auf (z. B.
+ * `receiptType: 'standard'` — bei den mit `defineEnum()` gebauten Enums ist
+ * der Objekt-Schluessel selbst die Nutzlast).
+ *
+ * Nur fuer den **Schreibpfad**: bevor dieses Paket selbst einen Wert nach
+ * aussen traegt, muss er bekannt sein — ein unbekannter Schluessel wirft.
+ * Fuer den Lesepfad (Daten, die vom Backend hereinkommen) siehe
+ * [readEnumKey]: dort darf ein einzelner unbekannter Wert nicht die ganze
+ * Belegliste zum Absturz bringen.
+ */
+export function requireEnumKey(enumObj, key, label) {
+    if (!Object.prototype.hasOwnProperty.call(enumObj, key)) {
+        throw new Error(`${label}: unbekannter Schluessel "${key}" in der Nutzlast`);
+    }
+    return enumObj[key];
+}
+/**
+ * Lesepfad-Pendant zu [requireEnumKey]: ein unbekannter Schluessel (z. B. ein
+ * neuer Belegtyp oder eine neue Zahlungsart, die dieses Paket noch nicht
+ * kennt) wirft nicht und wird auch nicht still zu `undefined` — der rohe
+ * Nutzlast-Schluessel bleibt als String erhalten. Ein Aufrufer, der eine
+ * Belegliste anzeigt, kann so alle Positionen weiterlesen; nur die unbekannte
+ * bleibt (erkennbar) unaufgeloest.
+ */
+export function readEnumKey(enumObj, key) {
+    return Object.prototype.hasOwnProperty.call(enumObj, key) ? enumObj[key] : key;
+}
+function findVatRate(rate) {
+    return Object.values(VatRate).find((v) => v.rate === rate);
+}
+/** Schreibpfad: loest einen Steuersatz anhand seines `rate`-Werts auf, wirft bei unbekanntem Satz. */
+export function requireVatRateByRate(rate) {
+    const eintrag = findVatRate(rate);
+    if (!eintrag) {
+        throw new Error(`Steuersatz: unbekannter Satz "${rate}" in der Nutzlast`);
+    }
+    return eintrag;
+}
+/** Lesepfad: unbekannter Satz bleibt als roher `rate`-Wert erhalten statt zu werfen oder `undefined` zu werden. */
+export function readVatRateByRate(rate) {
+    return findVatRate(rate) ?? rate;
+}

package/dist/esm/models/hobex-receipt.d.ts

@@ -0,0 +1,63 @@
+import { CreditCardProvider } from '../enums/index.js';
+/**
+ * Hobex-Kartenzahlungsbeleg — Zwilling von `HobexReceipt` in
+ * kasseneck_api/lib/models/hobex_receipt.dart.
+ *
+ * `amount`/`tip` kommen vom Hobex-Terminal als Euro-Gleitkommazahl ueber die
+ * Leitung (Terminal-API, nicht das Kasseneck-Backend) — das Nutzlast-Format
+ * bleibt deshalb bewusst Euro (siehe [toHobexReceiptPayload]/
+ * [fromHobexReceiptPayload]), intern wird ab hier exakt in Cent gefuehrt.
+ *
+ * Nur der Cloud-API-Pfad (`fromJson` im Dart-Vorbild) ist Teil dieses Pakets;
+ * das lokale HPS-Terminal (`fromHps`, TCP-Anbindung an ein physisches Geraet)
+ * ist wie SumUp/myPOS eine Android/Desktop-Geraete-Anbindung, die ein
+ * Browser-/Node-Paket nicht bedienen kann.
+ */
+export interface HobexReceipt {
+    transactionId: string;
+    tid: string;
+    receipt: string;
+    approvalCode: string;
+    reference?: string;
+    /** Normalisiert wie im Dart-Vorbild: `"YYYY-MM-DD HH:mm:ss"` (Bruchteil und `T` entfernt). */
+    transactionDate: string;
+    cardNumber: string;
+    cardExpiry: string;
+    brand: string;
+    cardIssuer: string;
+    responseCode: string;
+    transactionType: string;
+    currency: string;
+    amountCents: number;
+    tipCents: number;
+    cvm: string;
+    creditCardProvider: CreditCardProvider;
+}
+export interface HobexReceiptPayload {
+    transactionId: string;
+    tid: string;
+    receipt: string;
+    approvalCode: string;
+    reference: string | null | undefined;
+    transactionDate: string;
+    cardNumber: string;
+    cardExpiry: string;
+    brand: string;
+    cardIssuer: string;
+    responseCode: string;
+    transactionType: string;
+    currency: string;
+    amount: number;
+    tip: number;
+    cvm: string | number;
+}
+export declare function toHobexReceiptPayload(beleg: HobexReceipt): HobexReceiptPayload;
+export declare function fromHobexReceiptPayload(payload: HobexReceiptPayload): HobexReceipt;
+/**
+ * Wandelt den Beleg in die `cardPaymentData`-Map, die auf dem Kasseneck-Beleg
+ * landet (siehe [Receipt.cardPaymentData]). Bei HPS-Zahlungen kommen weitere
+ * Felder dazu, die nur das lokale Terminal liefert.
+ */
+export declare function hobexReceiptToCardPaymentData(beleg: HobexReceipt): Record<string, string>;
+/** Kartenzahlung erfordert eine Unterschrift (CVM-Code `"1"`). */
+export declare function hobexReceiptNeedsSignature(beleg: HobexReceipt): boolean;

package/dist/esm/models/hobex-receipt.js

@@ -0,0 +1,80 @@
+import { CreditCardProvider } from '../enums/index.js';
+import { centsToEuro } from '../money.js';
+export function toHobexReceiptPayload(beleg) {
+    return {
+        transactionId: beleg.transactionId,
+        tid: beleg.tid,
+        receipt: beleg.receipt,
+        approvalCode: beleg.approvalCode,
+        reference: beleg.reference ?? null,
+        transactionDate: beleg.transactionDate,
+        cardNumber: beleg.cardNumber,
+        cardExpiry: beleg.cardExpiry,
+        brand: beleg.brand,
+        cardIssuer: beleg.cardIssuer,
+        responseCode: beleg.responseCode,
+        transactionType: beleg.transactionType,
+        currency: beleg.currency,
+        // Euro-Umwandlung nur hier, an der Terminal-API-Grenze — siehe Kommentar oben.
+        amount: centsToEuro(beleg.amountCents),
+        tip: centsToEuro(beleg.tipCents),
+        cvm: beleg.cvm,
+    };
+}
+export function fromHobexReceiptPayload(payload) {
+    return {
+        transactionId: payload.transactionId,
+        tid: payload.tid,
+        receipt: payload.receipt,
+        approvalCode: payload.approvalCode,
+        reference: payload.reference ?? undefined,
+        // Kappt Bruchteilssekunden/Offset und ersetzt "T" durch ein Leerzeichen,
+        // exakt wie im Dart-Vorbild (transactionDate.split('.')[0].replaceAll('T', ' ')).
+        transactionDate: payload.transactionDate.split('.')[0].split('T').join(' '),
+        cardNumber: payload.cardNumber,
+        cardExpiry: payload.cardExpiry,
+        brand: payload.brand,
+        cardIssuer: payload.cardIssuer,
+        responseCode: payload.responseCode,
+        transactionType: payload.transactionType,
+        currency: payload.currency,
+        amountCents: Math.round((payload.amount ?? 0) * 100),
+        tipCents: Math.round((payload.tip ?? 0) * 100),
+        cvm: String(payload.cvm),
+        // Die Cloud-API-Nutzlast traegt keinen eigenen Provider-Schluessel — der
+        // Provider ergibt sich aus dem Transportweg (Cloud vs. HPS), nicht aus
+        // dem JSON. Das Dart-Vorbild setzt ihn in `fromJson` deshalb ebenfalls
+        // nicht, sondern belaesst den Konstruktor-Default.
+        creditCardProvider: CreditCardProvider.hobexCloudApi,
+    };
+}
+/**
+ * Wandelt den Beleg in die `cardPaymentData`-Map, die auf dem Kasseneck-Beleg
+ * landet (siehe [Receipt.cardPaymentData]). Bei HPS-Zahlungen kommen weitere
+ * Felder dazu, die nur das lokale Terminal liefert.
+ */
+export function hobexReceiptToCardPaymentData(beleg) {
+    const data = {
+        transactionId: beleg.transactionId,
+        date: beleg.transactionDate,
+        tid: beleg.tid,
+        no: beleg.receipt,
+        type: beleg.transactionType,
+        cardBrand: beleg.brand,
+        cardNumber: beleg.cardNumber,
+        responseCode: beleg.responseCode,
+        cvm: beleg.cvm,
+    };
+    if (beleg.creditCardProvider === CreditCardProvider.hobexHps) {
+        data.approvalCode = beleg.approvalCode;
+        data.cardExpiry = beleg.cardExpiry;
+        data.cardIssuer = beleg.cardIssuer;
+        data.amount = centsToEuro(beleg.amountCents).toFixed(2);
+        data.currency = beleg.currency;
+    }
+    return data;
+}
+/** Kartenzahlung erfordert eine Unterschrift (CVM-Code `"1"`). */
+export function hobexReceiptNeedsSignature(beleg) {
+    return beleg.cvm === '1';
+}

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

@@ -0,0 +1,10 @@
+export { type ReceiptItem, type ReceiptItemPayload, type ReceiptItemPayloadRead, toReceiptItemPayload, fromReceiptItemPayload, receiptItemTotalCents, receiptItemIsValid, negateReceiptItem, } from './receipt-item.js';
+export { type Voucher, type VoucherPayload, toVoucherPayload, fromVoucherPayload, voucherIsValid } from './voucher.js';
+export { type Receipt, type ReceiptPayload, type ReceiptPayloadRead, toReceiptPayload, fromReceiptPayload, receiptSubSumCents, receiptSumCents, } from './receipt.js';
+export { type CancellationOf, type CancellationItem, type Cancellation, type CancellationReason, CANCELLATION_REASONS, CANCELLATION_RESERVATION_MS, isCancellationReason, remainingQuantities, } from './cancellation.js';
+export { type ReceiptCompany, type ReceiptCompanyPayload, fromReceiptCompanyPayload, receiptCompanyTaxInfo, } from './receipt-company.js';
+export { type Cashregister, type CashregisterOnboarding, type CashregisterPayload, type CashregisterOnboardingPayload, fromCashregisterPayload, } from './cashregister.js';
+export { type ReceiptSummary, type ReceiptSummaryPayload, fromReceiptSummaryPayload, type ZeroKind, ZERO_KINDS, istZeroKind } from './receipt-summary.js';
+export { type ReportMonth, reportMonthFromDate, previousReportMonth, nextReportMonth, reportMonthKey, reportMonthReadable, } from './report-month.js';
+export { type StripeUrlSession, type StripeUrlSessionPayload, toStripeUrlSessionPayload, fromStripeUrlSessionPayload, } from './stripe-url-session.js';
+export { type HobexReceipt, type HobexReceiptPayload, toHobexReceiptPayload, fromHobexReceiptPayload, hobexReceiptToCardPaymentData, hobexReceiptNeedsSignature, } from './hobex-receipt.js';

package/dist/esm/models/index.js

@@ -0,0 +1,10 @@
+export { toReceiptItemPayload, fromReceiptItemPayload, receiptItemTotalCents, receiptItemIsValid, negateReceiptItem, } from './receipt-item.js';
+export { toVoucherPayload, fromVoucherPayload, voucherIsValid } from './voucher.js';
+export { toReceiptPayload, fromReceiptPayload, receiptSubSumCents, receiptSumCents, } from './receipt.js';
+export { CANCELLATION_REASONS, CANCELLATION_RESERVATION_MS, isCancellationReason, remainingQuantities, } from './cancellation.js';
+export { fromReceiptCompanyPayload, receiptCompanyTaxInfo, } from './receipt-company.js';
+export { fromCashregisterPayload, } from './cashregister.js';
+export { fromReceiptSummaryPayload, ZERO_KINDS, istZeroKind } from './receipt-summary.js';
+export { reportMonthFromDate, previousReportMonth, nextReportMonth, reportMonthKey, reportMonthReadable, } from './report-month.js';
+export { toStripeUrlSessionPayload, fromStripeUrlSessionPayload, } from './stripe-url-session.js';
+export { toHobexReceiptPayload, fromHobexReceiptPayload, hobexReceiptToCardPaymentData, hobexReceiptNeedsSignature, } from './hobex-receipt.js';

package/dist/esm/models/receipt-company.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Firmen- und Druckdaten eines Belegs — Zwilling der Metadaten von
+ * `KasseneckReceipt` in kasseneck_api/lib/models/kasseneck_receipt.dart
+ * (`toMetadataJson`/`fromMetadata`).
+ *
+ * Das Backend liefert sie **neben** dem Beleg: `getReceipt` und `createReceipt`
+ * legen Firma, Anschrift, Steuernummer, UID, Fusszeilen, Logo-Adresse und das
+ * Kleinunternehmer-Kennzeichen direkt in die Antwort (functions/index.js).
+ * Zum RKSV-Kernbeleg gehoeren sie nicht — sie betreffen ausschliesslich die
+ * Darstellung. Deshalb stehen sie hier als eigenes Modell und nicht in
+ * [Receipt]: derselbe Beleg, spaeter erneut gedruckt, kann eine
+ * zwischenzeitlich geaenderte Fusszeile tragen.
+ *
+ * **Gotcha:** `thanks_message` liefert nur `getReceipt`, `createReceipt`
+ * nicht (functions/index.js, Antwortbloecke von `getReceipt` bzw.
+ * `createReceipt`). Das Feld ist deshalb kein Pflichtfeld der Nutzlast; ohne
+ * es bleibt [thanksMessage] leer.
+ */
+export interface ReceiptCompany {
+    companyName: string;
+    street: string;
+    zip: string;
+    city: string;
+    phone: string;
+    /** UID (Umsatzsteuer-Identifikationsnummer); fehlt bei Kleinunternehmern. */
+    uid?: string;
+    /** Steuernummer des Finanzamts. */
+    taxnr: string;
+    /** Kleinunternehmer nach § 6 Abs 1 Z 27 UStG (keine USt im Ausweis). */
+    isSmallBusiness: boolean;
+    footer1: string;
+    footer2: string;
+    footer3?: string;
+    footer4?: string;
+    /** Adresse des Firmenlogos; dieses Paket laedt und zeichnet es nicht. */
+    logoUrl?: string;
+    /** Dankestext am Belegende, je Zeile ein Eintrag. */
+    thanksMessage: string[];
+    /** Kreiseck-Branding am Belegende (Firestore-Flag `branding.kreiseck_logo`). */
+    showKreiseckLogo: boolean;
+}
+/**
+ * Nutzlast-Form, die dieses Paket **liest** — die Feldnamen der Backend-
+ * Antwort. Alles ist optional: ein Kundendokument ohne gepflegte Anschrift
+ * oder Fusszeile liefert die Felder als `null` oder gar nicht, und ein
+ * fehlender Firmenname darf keinen Belegdruck verhindern.
+ */
+export interface ReceiptCompanyPayload {
+    company?: string | null;
+    street?: string | null;
+    zip?: string | null;
+    city?: string | null;
+    phone?: string | null;
+    uid?: string | null;
+    taxnr?: string | null;
+    is_small_business?: boolean | null;
+    footer1?: string | null;
+    footer2?: string | null;
+    footer3?: string | null;
+    footer4?: string | null;
+    logo_url?: string | null;
+    /** Nur `getReceipt` liefert dieses Feld — siehe Modulkommentar. */
+    thanks_message?: string | null;
+    kreiseck_logo?: boolean | null;
+}
+export declare function fromReceiptCompanyPayload(payload: ReceiptCompanyPayload): ReceiptCompany;
+/**
+ * Steuerangabe im Belegkopf — Zwilling von `KasseneckReceipt.taxInfo`: die UID,
+ * wenn es eine gibt, sonst die Steuernummer.
+ */
+export declare function receiptCompanyTaxInfo(company: ReceiptCompany): string;

package/dist/esm/models/receipt-company.js

@@ -0,0 +1,48 @@
+/** Leere Zeichenkette statt `undefined` — siehe [ReceiptCompanyPayload]. */
+const text = (wert) => (typeof wert === 'string' ? wert : '');
+/**
+ * Zerlegt den Dankestext in Zeilen. Das Vorbild trennt an der **Zeichenfolge**
+ * `\n` (Backslash + n), nicht am Zeilenumbruch — so legt es die Flutter-Seite
+ * auch wieder ab (`toMetadataJson`). Ein echter Zeilenumbruch wird zusaetzlich
+ * getrennt: er kommt aus einem mehrzeiligen Eingabefeld im Panel und wuerde
+ * sonst als Umbruch **innerhalb** einer Layout-Zeile weiterwandern.
+ */
+function zeilen(wert) {
+    if (typeof wert !== 'string' || wert.length === 0) {
+        return [];
+    }
+    return wert.split(/\\n|\r?\n/);
+}
+export function fromReceiptCompanyPayload(payload) {
+    const firma = {
+        companyName: text(payload.company),
+        street: text(payload.street),
+        zip: text(payload.zip),
+        city: text(payload.city),
+        phone: text(payload.phone),
+        taxnr: text(payload.taxnr),
+        isSmallBusiness: payload.is_small_business === true,
+        footer1: text(payload.footer1),
+        footer2: text(payload.footer2),
+        thanksMessage: zeilen(payload.thanks_message),
+        showKreiseckLogo: payload.kreiseck_logo === true,
+    };
+    // Die vier Kann-Felder bleiben weg, wenn sie leer sind — ein leerer String
+    // in `footer3` erzeugte sonst eine leere Zeile auf dem Beleg.
+    if (payload.uid)
+        firma.uid = payload.uid;
+    if (payload.footer3)
+        firma.footer3 = payload.footer3;
+    if (payload.footer4)
+        firma.footer4 = payload.footer4;
+    if (payload.logo_url)
+        firma.logoUrl = payload.logo_url;
+    return firma;
+}
+/**
+ * Steuerangabe im Belegkopf — Zwilling von `KasseneckReceipt.taxInfo`: die UID,
+ * wenn es eine gibt, sonst die Steuernummer.
+ */
+export function receiptCompanyTaxInfo(company) {
+    return company.uid !== undefined && company.uid.length > 0 ? company.uid : company.taxnr;
+}