@hub-kit/core 0.3.0

package/dist/components/tour/use-tour.d.ts

@@ -0,0 +1,3 @@
+import { type TourState } from "./tour-context";
+export declare function useTour(): TourState | null;
+export declare function useTourPlaceholderData(): boolean;

package/dist/components/tour/use-tour.js

@@ -0,0 +1,9 @@
+import { useContext } from "react";
+import { TourContext } from "./tour-context.js";
+export function useTour() {
+    return useContext(TourContext);
+}
+export function useTourPlaceholderData() {
+    const tour = useContext(TourContext);
+    return tour?.showsPlaceholderData === true;
+}

package/dist/hooks/use-mobile.d.ts

@@ -0,0 +1 @@
+export declare function useIsMobile(): boolean;

package/dist/hooks/use-mobile.js

@@ -0,0 +1,15 @@
+import { useEffect, useState } from "react";
+const MOBILE_BREAKPOINT = 640;
+export function useIsMobile() {
+    const [isMobile, setIsMobile] = useState(undefined);
+    useEffect(() => {
+        const mql = window.matchMedia(`(max-width: ${MOBILE_BREAKPOINT - 1}px)`);
+        const onChange = () => {
+            setIsMobile(window.innerWidth < MOBILE_BREAKPOINT);
+        };
+        mql.addEventListener("change", onChange);
+        setIsMobile(window.innerWidth < MOBILE_BREAKPOINT);
+        return () => mql.removeEventListener("change", onChange);
+    }, []);
+    return !!isMobile;
+}

package/dist/i18n/index.d.ts

@@ -0,0 +1,15 @@
+export { englishProcessingLogLabels } from "../pages/processing-log/labels";
+export { englishNotificationsPageLabels } from "../pages/notifications/labels";
+export { englishTeamPageLabels } from "../pages/team/labels";
+export { englishTrashPageLabels } from "../pages/trash/labels";
+export { englishCustomersLabels } from "../pages/customers/labels";
+export { englishCompaniesLabels } from "../pages/companies/labels";
+export { englishPropertiesLabels } from "../pages/properties/labels";
+export { englishExclusionRulesLabels } from "../pages/exclusion-rules/labels";
+export { englishVatRulesLabels } from "../pages/vat-rules/labels";
+export { englishFileNamingLabels } from "../pages/file-naming/labels";
+export { englishReminderDialogLabels } from "../components/notifications/reminder-dialog";
+export { englishErrorStateLabels, englishPaginationLabels } from "../components/feedback";
+export { englishFormatters } from "../lib/formatters";
+export { englishOverviewLabels } from "../pages/overview/labels";
+export { englishTourLabels } from "../components/tour/labels";

package/dist/i18n/index.js

@@ -0,0 +1,15 @@
+export { englishProcessingLogLabels } from "../pages/processing-log/labels.js";
+export { englishNotificationsPageLabels } from "../pages/notifications/labels.js";
+export { englishTeamPageLabels } from "../pages/team/labels.js";
+export { englishTrashPageLabels } from "../pages/trash/labels.js";
+export { englishCustomersLabels } from "../pages/customers/labels.js";
+export { englishCompaniesLabels } from "../pages/companies/labels.js";
+export { englishPropertiesLabels } from "../pages/properties/labels.js";
+export { englishExclusionRulesLabels } from "../pages/exclusion-rules/labels.js";
+export { englishVatRulesLabels } from "../pages/vat-rules/labels.js";
+export { englishFileNamingLabels } from "../pages/file-naming/labels.js";
+export { englishReminderDialogLabels } from "../components/notifications/reminder-dialog.js";
+export { englishErrorStateLabels, englishPaginationLabels } from "../components/feedback/index.js";
+export { englishFormatters } from "../lib/formatters.js";
+export { englishOverviewLabels } from "../pages/overview/labels.js";
+export { englishTourLabels } from "../components/tour/labels.js";

package/dist/lib/bank-import/classify.d.ts

@@ -0,0 +1,8 @@
+export type TransactionType = "ueberweisung" | "lastschrift" | "kreditkarte" | "kartenzahlung" | "gutschrift" | "unbekannt";
+export interface ClassifyInput {
+    bookingText?: string | null;
+    paymentReference?: string | null;
+    amount?: number | null;
+    productType?: string | null;
+}
+export declare function classifyTransactionType(input: ClassifyInput): TransactionType;

package/dist/lib/bank-import/classify.js

@@ -0,0 +1,89 @@
+function normalize(value) {
+    return (value ?? "")
+        .toLowerCase()
+        .replace(/ä/g, "ae")
+        .replace(/ö/g, "oe")
+        .replace(/ü/g, "ue")
+        .replace(/ß/g, "ss")
+        .replace(/[^a-z0-9]+/g, " ")
+        .trim();
+}
+function hasPart(haystack, parts) {
+    return parts.some((p) => haystack.includes(p));
+}
+function hasWord(haystack, words) {
+    return words.some((w) => haystack === w || new RegExp(`(^| )${w}( |$)`).test(haystack));
+}
+const CARD_ACCOUNT_PARTS = ["kreditkarte", "kreditkarten"];
+const CARD_ACCOUNT_WORDS = [
+    "visa",
+    "mastercard",
+    "eurocard",
+    "amex",
+    "american express",
+    "maestro",
+    "creditcard",
+    "credit card",
+];
+const CARD_SETTLEMENT_PARTS = [
+    "kreditkarte",
+    "kreditkarten",
+    "kartenabrechnung",
+    "kartenumsaetze",
+    "wochenabrechnung",
+    "monatsabrechnung",
+];
+const CARD_SETTLEMENT_WORDS = ["visa", "mastercard", "eurocard", "amex", "american express"];
+const CARD_PAYMENT_PARTS = [
+    "kartenzahlung",
+    "kartenverfuegung",
+    "girocard",
+    "debitkarte",
+    "bargeldauszahlung",
+    "geldautomat",
+];
+const CARD_PAYMENT_WORDS = ["elv", "ec cash", "pos", "ga auszahlung"];
+const CARD_REF_PREFIXES = ["ec", "ga"];
+const DEBIT_PARTS = ["lastschrift", "einzugsermaechtigung", "abbuchung", "basisls", "firmenls"];
+const TRANSFER_PARTS = [
+    "ueberweisung",
+    "ueberw",
+    "uebertrag",
+    "dauerauftrag",
+    "umbuchung",
+    "echtzeitzahlung",
+];
+const TRANSFER_WORDS = ["sepa ct", "lohn", "gehalt", "sammler"];
+const CREDIT_PARTS = ["gutschrift", "zinsen", "erstattung", "rueckzahlung", "einzahlung", "storno"];
+function isCardAccount(productType) {
+    const p = normalize(productType);
+    return !!p && (hasPart(p, CARD_ACCOUNT_PARTS) || hasWord(p, CARD_ACCOUNT_WORDS));
+}
+function classifyText(text) {
+    if (!text)
+        return null;
+    if (hasPart(text, CARD_SETTLEMENT_PARTS) || hasWord(text, CARD_SETTLEMENT_WORDS)) {
+        return "kreditkarte";
+    }
+    if (hasPart(text, CARD_PAYMENT_PARTS) ||
+        hasWord(text, CARD_PAYMENT_WORDS) ||
+        CARD_REF_PREFIXES.includes(text.split(" ")[0])) {
+        return "kartenzahlung";
+    }
+    if (hasPart(text, DEBIT_PARTS))
+        return "lastschrift";
+    if (hasPart(text, TRANSFER_PARTS) || hasWord(text, TRANSFER_WORDS))
+        return "ueberweisung";
+    if (hasPart(text, CREDIT_PARTS))
+        return "gutschrift";
+    return null;
+}
+export function classifyTransactionType(input) {
+    const fromText = classifyText(normalize(input.bookingText)) ?? classifyText(normalize(input.paymentReference));
+    if (isCardAccount(input.productType)) {
+        if (fromText === "kreditkarte")
+            return "kreditkarte";
+        return (input.amount ?? 0) > 0 ? "gutschrift" : "kartenzahlung";
+    }
+    return fromText ?? "unbekannt";
+}

package/dist/lib/bank-import/column-guess.d.ts

@@ -0,0 +1,2 @@
+import type { ColumnMapping } from "./types";
+export declare function guessColumnMapping(headers: string[]): ColumnMapping;

package/dist/lib/bank-import/column-guess.js

@@ -0,0 +1,40 @@
+const KEYWORDS = [
+    { field: "booking_date", keywords: ["buchungstag", "buchungsdatum", "booking date", "datum"] },
+    { field: "value_date", keywords: ["valuta", "wertstellung", "value date"] },
+    { field: "amount", keywords: ["betrag", "amount", "umsatz"] },
+    { field: "amountDebit", keywords: ["soll", "belastung", "debit", "ausgang"] },
+    { field: "amountCredit", keywords: ["haben", "gutschrift", "credit", "eingang"] },
+    { field: "currency", keywords: ["währung", "waehrung", "currency"] },
+    {
+        field: "counterparty_holder",
+        keywords: ["empfänger", "empfaenger", "auftraggeber", "zahlungspflichtiger", "name", "beguenstigter", "begünstigter"],
+    },
+    { field: "counterparty_iban", keywords: ["iban"] },
+    { field: "payment_reference", keywords: ["verwendungszweck", "referenz", "reference", "buchungstext", "purpose"] },
+    { field: "booking_text", keywords: ["buchungsart", "text", "umsatzart", "vorgang", "description"] },
+];
+function normalizeHeader(header) {
+    return header
+        .toLowerCase()
+        .trim()
+        .replace(/[äÄ]/g, "ae")
+        .replace(/[öÖ]/g, "oe")
+        .replace(/[üÜ]/g, "ue")
+        .replace(/ß/g, "ss");
+}
+export function guessColumnMapping(headers) {
+    const mapping = {};
+    const claimed = new Set();
+    for (const header of headers) {
+        const normalized = normalizeHeader(header);
+        const match = KEYWORDS.find((k) => !claimed.has(k.field) && k.keywords.some((kw) => normalized.includes(kw)));
+        if (!match)
+            continue;
+        claimed.add(match.field);
+        mapping[match.field] = header;
+    }
+    if (mapping.amountDebit || mapping.amountCredit) {
+        delete mapping.amount;
+    }
+    return mapping;
+}

package/dist/lib/bank-import/csv.d.ts

@@ -0,0 +1,3 @@
+import type { ParsedTable } from "./types";
+export declare function parseCsv(text: string): ParsedTable;
+export declare function parseCsvFile(file: File): Promise<ParsedTable>;

package/dist/lib/bank-import/csv.js

@@ -0,0 +1,20 @@
+import Papa from "papaparse";
+export function parseCsv(text) {
+    const result = Papa.parse(text, {
+        header: true,
+        skipEmptyLines: true,
+        delimitersToGuess: [",", ";", "\t", "|"],
+    });
+    const fatal = result.errors.find((e) => e.type !== "FieldMismatch");
+    if (fatal) {
+        throw new Error(`Could not read the CSV file: ${fatal.message} (row ${(fatal.row ?? 0) + 2})`);
+    }
+    return {
+        headers: result.meta.fields ?? [],
+        rows: result.data,
+    };
+}
+export async function parseCsvFile(file) {
+    const text = await file.text();
+    return parseCsv(text);
+}

package/dist/lib/bank-import/duplicates.d.ts

@@ -0,0 +1,2 @@
+import type { NormalizedRow } from "./types";
+export declare function findSuspectedDuplicates(rows: NormalizedRow[]): Set<number>;

package/dist/lib/bank-import/duplicates.js

@@ -0,0 +1,21 @@
+function normalizeText(value) {
+    return (value ?? "").trim().toLowerCase();
+}
+function contentKey(row) {
+    return [row.booking_date, row.amount.toFixed(2), row.currency ?? "", normalizeText(row.payment_reference), normalizeText(row.counterparty_iban)].join("|");
+}
+export function findSuspectedDuplicates(rows) {
+    const counts = new Map();
+    rows.forEach((row, i) => {
+        const key = contentKey(row);
+        const list = counts.get(key) ?? [];
+        list.push(i);
+        counts.set(key, list);
+    });
+    const suspects = new Set();
+    for (const indexes of counts.values()) {
+        if (indexes.length > 1)
+            indexes.forEach((i) => suspects.add(i));
+    }
+    return suspects;
+}

package/dist/lib/bank-import/index.d.ts

@@ -0,0 +1,12 @@
+export type { NormalizedRow, ParseIssueCode, ParseIssue, NormalizeResult, ParsedTable, SingleTargetField, ColumnMapping } from "./types";
+export { REQUIRED_FIELDS } from "./types";
+export { classifyTransactionType } from "./classify";
+export type { ClassifyInput, TransactionType } from "./classify";
+export { guessColumnMapping } from "./column-guess";
+export { parseCsv, parseCsvFile } from "./csv";
+export { parseXlsxFile } from "./xlsx";
+export { detectFormat, parseBankFile } from "./parse-file";
+export type { DetectedFormat } from "./parse-file";
+export { parseFlexibleDate, parseFlexibleAmount, normalizeTable } from "./normalize";
+export { findSuspectedDuplicates } from "./duplicates";
+export { loadStoredMapping, saveMapping } from "./mapping-storage";

package/dist/lib/bank-import/index.js

@@ -0,0 +1,9 @@
+export { REQUIRED_FIELDS } from "./types.js";
+export { classifyTransactionType } from "./classify.js";
+export { guessColumnMapping } from "./column-guess.js";
+export { parseCsv, parseCsvFile } from "./csv.js";
+export { parseXlsxFile } from "./xlsx.js";
+export { detectFormat, parseBankFile } from "./parse-file.js";
+export { parseFlexibleDate, parseFlexibleAmount, normalizeTable } from "./normalize.js";
+export { findSuspectedDuplicates } from "./duplicates.js";
+export { loadStoredMapping, saveMapping } from "./mapping-storage.js";

package/dist/lib/bank-import/mapping-storage.d.ts

@@ -0,0 +1,3 @@
+import type { ColumnMapping } from "./types";
+export declare function loadStoredMapping(headers: string[]): ColumnMapping | null;
+export declare function saveMapping(headers: string[], mapping: ColumnMapping): void;

package/dist/lib/bank-import/mapping-storage.js

@@ -0,0 +1,29 @@
+const STORAGE_PREFIX = "hub-kit.bank-import.mapping.";
+function fingerprint(headers) {
+    const key = [...headers]
+        .map((h) => h.trim().toLowerCase())
+        .sort()
+        .join("|");
+    let hash = 0;
+    for (let i = 0; i < key.length; i++) {
+        hash = (hash * 31 + key.charCodeAt(i)) | 0;
+    }
+    return hash.toString(36);
+}
+export function loadStoredMapping(headers) {
+    try {
+        const raw = localStorage.getItem(STORAGE_PREFIX + fingerprint(headers));
+        return raw ? JSON.parse(raw) : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function saveMapping(headers, mapping) {
+    try {
+        localStorage.setItem(STORAGE_PREFIX + fingerprint(headers), JSON.stringify(mapping));
+    }
+    catch {
+        return;
+    }
+}

package/dist/lib/bank-import/normalize.d.ts

@@ -0,0 +1,4 @@
+import type { ColumnMapping, NormalizeResult, ParsedTable } from "./types";
+export declare function parseFlexibleDate(value: string): string | null;
+export declare function parseFlexibleAmount(value: string): number | null;
+export declare function normalizeTable(table: ParsedTable, mapping: ColumnMapping): NormalizeResult;

package/dist/lib/bank-import/normalize.js

@@ -0,0 +1,82 @@
+export function parseFlexibleDate(value) {
+    const v = value.trim();
+    if (!v)
+        return null;
+    const iso = v.match(/^(\d{4})-(\d{2})-(\d{2})/);
+    if (iso)
+        return `${iso[1]}-${iso[2]}-${iso[3]}`;
+    const german = v.match(/^(\d{1,2})\.(\d{1,2})\.(\d{2}|\d{4})$/);
+    if (german) {
+        const [, d, m, yRaw] = german;
+        const y = yRaw.length === 2 ? `20${yRaw}` : yRaw;
+        const dd = d.padStart(2, "0");
+        const mm = m.padStart(2, "0");
+        if (Number(mm) < 1 || Number(mm) > 12 || Number(dd) < 1 || Number(dd) > 31)
+            return null;
+        return `${y}-${mm}-${dd}`;
+    }
+    return null;
+}
+export function parseFlexibleAmount(value) {
+    let v = value.trim();
+    if (!v)
+        return null;
+    const trailingMinus = /-\s*$/.test(v);
+    v = v.replace(/[^\d,.-]/g, "");
+    const hasComma = v.includes(",");
+    const hasDot = v.includes(".");
+    if (hasComma && hasDot) {
+        v = v.lastIndexOf(",") > v.lastIndexOf(".") ? v.replace(/\./g, "").replace(",", ".") : v.replace(/,/g, "");
+    }
+    else if (hasComma) {
+        v = v.replace(",", ".");
+    }
+    const n = Number(v);
+    if (!Number.isFinite(n))
+        return null;
+    return trailingMinus && n > 0 ? -n : n;
+}
+function cell(row, header) {
+    if (!header)
+        return "";
+    return (row[header] ?? "").trim();
+}
+export function normalizeTable(table, mapping) {
+    const rows = [];
+    const issues = [];
+    table.rows.forEach((row, rowIndex) => {
+        const bookingDateRaw = cell(row, mapping.booking_date);
+        const bookingDate = parseFlexibleDate(bookingDateRaw);
+        if (!bookingDate) {
+            issues.push({ rowIndex, code: "missing_booking_date", rawValue: bookingDateRaw });
+            return;
+        }
+        let amount;
+        if (mapping.amountDebit || mapping.amountCredit) {
+            const debit = parseFlexibleAmount(cell(row, mapping.amountDebit)) ?? 0;
+            const credit = parseFlexibleAmount(cell(row, mapping.amountCredit)) ?? 0;
+            amount = credit - Math.abs(debit);
+            if (debit === 0 && credit === 0)
+                amount = null;
+        }
+        else {
+            amount = parseFlexibleAmount(cell(row, mapping.amount));
+        }
+        if (amount === null) {
+            issues.push({ rowIndex, code: "missing_amount", rawValue: cell(row, mapping.amount) });
+            return;
+        }
+        rows.push({
+            booking_date: bookingDate,
+            value_date: parseFlexibleDate(cell(row, mapping.value_date)),
+            amount,
+            currency: cell(row, mapping.currency) || null,
+            counterparty_holder: cell(row, mapping.counterparty_holder) || null,
+            counterparty_iban: cell(row, mapping.counterparty_iban).replace(/\s+/g, "") || null,
+            payment_reference: cell(row, mapping.payment_reference) || null,
+            booking_text: cell(row, mapping.booking_text) || null,
+            provider_ref: null,
+        });
+    });
+    return { rows, issues };
+}

package/dist/lib/bank-import/parse-file.d.ts

@@ -0,0 +1,7 @@
+import type { ParsedTable } from "./types";
+export type DetectedFormat = "csv" | "xlsx" | "pdf" | null;
+export declare function detectFormat(file: File): DetectedFormat;
+export declare function parseBankFile(file: File): Promise<{
+    format: "csv" | "xlsx";
+    table: ParsedTable;
+}>;

package/dist/lib/bank-import/parse-file.js

@@ -0,0 +1,23 @@
+import { parseCsvFile } from "./csv.js";
+import { parseXlsxFile } from "./xlsx.js";
+export function detectFormat(file) {
+    const name = file.name.toLowerCase();
+    if (name.endsWith(".csv") || name.endsWith(".txt"))
+        return "csv";
+    if (name.endsWith(".xlsx") || name.endsWith(".xls"))
+        return "xlsx";
+    if (name.endsWith(".pdf"))
+        return "pdf";
+    return null;
+}
+export async function parseBankFile(file) {
+    const format = detectFormat(file);
+    if (format !== "csv" && format !== "xlsx") {
+        throw new Error("Unsupported file format. Upload a CSV or Excel (.xlsx) file.");
+    }
+    const table = format === "csv" ? await parseCsvFile(file) : await parseXlsxFile(file);
+    if (table.headers.length === 0 || table.rows.length === 0) {
+        throw new Error("The file has no recognizable columns or rows.");
+    }
+    return { format, table };
+}

package/dist/lib/bank-import/types.d.ts

@@ -0,0 +1,31 @@
+export interface NormalizedRow {
+    booking_date: string;
+    value_date: string | null;
+    amount: number;
+    currency: string | null;
+    counterparty_holder: string | null;
+    counterparty_iban: string | null;
+    payment_reference: string | null;
+    booking_text: string | null;
+    provider_ref: string | null;
+}
+export type ParseIssueCode = "missing_booking_date" | "missing_amount";
+export interface ParseIssue {
+    rowIndex: number;
+    code: ParseIssueCode;
+    rawValue: string;
+}
+export interface NormalizeResult {
+    rows: NormalizedRow[];
+    issues: ParseIssue[];
+}
+export interface ParsedTable {
+    headers: string[];
+    rows: Record<string, string>[];
+}
+export type SingleTargetField = "booking_date" | "value_date" | "amount" | "currency" | "counterparty_holder" | "counterparty_iban" | "payment_reference" | "booking_text";
+export type ColumnMapping = Partial<Record<SingleTargetField, string>> & {
+    amountDebit?: string;
+    amountCredit?: string;
+};
+export declare const REQUIRED_FIELDS: readonly SingleTargetField[];

package/dist/lib/bank-import/types.js

@@ -0,0 +1 @@
+export const REQUIRED_FIELDS = ["booking_date"];

package/dist/lib/bank-import/xlsx.d.ts

@@ -0,0 +1,2 @@
+import type { ParsedTable } from "./types";
+export declare function parseXlsxFile(file: File): Promise<ParsedTable>;

package/dist/lib/bank-import/xlsx.js

@@ -0,0 +1,25 @@
+import * as XLSX from "xlsx";
+export async function parseXlsxFile(file) {
+    const buffer = await file.arrayBuffer();
+    const workbook = XLSX.read(buffer, { type: "array", cellDates: true });
+    const sheetName = workbook.SheetNames[0];
+    if (!sheetName)
+        throw new Error("The Excel file has no sheets.");
+    const sheet = workbook.Sheets[sheetName];
+    const matrix = XLSX.utils.sheet_to_json(sheet, { header: 1, raw: false, defval: "" });
+    const headerRowIndex = matrix.findIndex((row) => row.some((cell) => String(cell ?? "").trim() !== ""));
+    if (headerRowIndex === -1)
+        throw new Error("The Excel file has no data.");
+    const headers = matrix[headerRowIndex].map((cell) => String(cell ?? "").trim());
+    const rows = matrix
+        .slice(headerRowIndex + 1)
+        .filter((row) => row.some((cell) => String(cell ?? "").trim() !== ""))
+        .map((row) => {
+        const record = {};
+        headers.forEach((header, i) => {
+            record[header] = String(row[i] ?? "").trim();
+        });
+        return record;
+    });
+    return { headers, rows };
+}

package/dist/lib/class-names.d.ts

@@ -0,0 +1,2 @@
+import { type ClassValue } from "clsx";
+export declare function cn(...inputs: ClassValue[]): string;

package/dist/lib/class-names.js

@@ -0,0 +1,5 @@
+import { clsx } from "clsx";
+import { twMerge } from "tailwind-merge";
+export function cn(...inputs) {
+    return twMerge(clsx(inputs));
+}

package/dist/lib/download.d.ts

@@ -0,0 +1,2 @@
+export declare function downloadTextFile(fileName: string, content: string, mimeType?: string): void;
+export declare function toCsv(rows: string[][]): string;

package/dist/lib/download.js

@@ -0,0 +1,14 @@
+export function downloadTextFile(fileName, content, mimeType = "text/csv") {
+    const blob = new Blob([content], { type: `${mimeType};charset=utf-8` });
+    const url = URL.createObjectURL(blob);
+    const link = document.createElement("a");
+    link.href = url;
+    link.download = fileName;
+    link.click();
+    URL.revokeObjectURL(url);
+}
+export function toCsv(rows) {
+    return rows
+        .map((row) => row.map((cell) => `"${cell.replace(/"/g, '""')}"`).join(";"))
+        .join("\r\n");
+}

package/dist/lib/formatters.d.ts

@@ -0,0 +1,6 @@
+export interface Formatters {
+    formatDate: (isoDate: string | null | undefined) => string;
+    formatDateTime: (isoDateTime: string | null | undefined) => string;
+    formatMoney: (amount: number | null | undefined) => string;
+}
+export declare const englishFormatters: Formatters;

package/dist/lib/formatters.js

@@ -0,0 +1,24 @@
+const EMPTY = "—";
+export const englishFormatters = {
+    formatDate(isoDate) {
+        if (!isoDate)
+            return EMPTY;
+        const date = new Date(isoDate.length <= 10 ? `${isoDate}T00:00:00` : isoDate);
+        if (Number.isNaN(date.getTime()))
+            return EMPTY;
+        return date.toLocaleDateString("en-GB", { year: "numeric", month: "long", day: "numeric" });
+    },
+    formatDateTime(isoDateTime) {
+        if (!isoDateTime)
+            return EMPTY;
+        const date = new Date(isoDateTime);
+        if (Number.isNaN(date.getTime()))
+            return EMPTY;
+        return date.toLocaleString("en-GB", { dateStyle: "long", timeStyle: "short" });
+    },
+    formatMoney(amount) {
+        if (amount === null || amount === undefined)
+            return EMPTY;
+        return new Intl.NumberFormat("en-GB", { style: "currency", currency: "EUR" }).format(amount);
+    },
+};

package/dist/lib/index.d.ts

@@ -0,0 +1,9 @@
+export { cn } from "./class-names";
+export type { QueryResult, MutationResult } from "./query-result";
+export type { Formatters } from "./formatters";
+export { englishFormatters } from "./formatters";
+export { downloadTextFile, toCsv } from "./download";
+export * from "./bank-import";
+export * from "./opos-whitelist";
+export { createPlaceholderOverviewAdapter, englishPlaceholderOverviewLabels, } from "./tour-placeholders";
+export type { PlaceholderOverviewLabels } from "./tour-placeholders";

package/dist/lib/index.js

@@ -0,0 +1,6 @@
+export { cn } from "./class-names.js";
+export { englishFormatters } from "./formatters.js";
+export { downloadTextFile, toCsv } from "./download.js";
+export * from "./bank-import/index.js";
+export * from "./opos-whitelist/index.js";
+export { createPlaceholderOverviewAdapter, englishPlaceholderOverviewLabels, } from "./tour-placeholders/index.js";

package/dist/lib/opos-whitelist/index.d.ts

@@ -0,0 +1,2 @@
+export { OPOS_CATEGORIES, OPOS_SCOPES, OPOS_TERM_MIN_LENGTH, oposNorm, asciiSpelling, shadowingRule, } from "./opos";
+export type { OposCategory, OposScope } from "./opos";

package/dist/lib/opos-whitelist/index.js

@@ -0,0 +1 @@
+export { OPOS_CATEGORIES, OPOS_SCOPES, OPOS_TERM_MIN_LENGTH, oposNorm, asciiSpelling, shadowingRule, } from "./opos.js";

package/dist/lib/opos-whitelist/opos.d.ts

@@ -0,0 +1,14 @@
+export type OposCategory = "salary" | "tax_prepayment" | "private_withdrawal" | "rebooking" | "loan_installment" | "fee_interest" | "atm_withdrawal" | "other";
+export declare const OPOS_CATEGORIES: readonly OposCategory[];
+export type OposScope = "reference" | "counterparty" | "iban" | "booking_text" | "any";
+export declare const OPOS_SCOPES: readonly OposScope[];
+export declare const OPOS_TERM_MIN_LENGTH = 3;
+export declare function oposNorm(term: string): string;
+export declare function asciiSpelling(term: string): string | null;
+export declare function shadowingRule<T extends {
+    id: string;
+    term: string;
+    scope: OposScope;
+    is_active: boolean;
+    created_at: string;
+}>(rule: T, all: readonly T[]): T | null;