@hub-kit/core 0.3.0

package/dist/pages/customers/new-customer-dialog.js

@@ -0,0 +1,93 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState } from "react";
+import { Plus } from "lucide-react";
+import { toast } from "sonner";
+import { Button } from "../../ui/button.js";
+import { Combobox } from "../../ui/combobox.js";
+import { Input } from "../../ui/input.js";
+import { Label } from "../../ui/label.js";
+import { Switch } from "../../ui/switch.js";
+import { Dialog, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogTitle, DialogTrigger, } from "../../ui/dialog.js";
+import { readableErrorMessage } from "../../components/feedback/query-states.js";
+import { FieldErrorText, RequiredMark } from "./form-hints.js";
+const EMAIL_PATTERN = /^[^\s@]+@[^\s@]+\.[^\s@]{2,}$/;
+const ZIP_PATTERN = /^\d{4,5}$/;
+const EMPTY_FORM = {
+    companyId: "",
+    isCompany: true,
+    name: "",
+    contactPerson: "",
+    email: "",
+    phone: "",
+    addressStreet: "",
+    addressZip: "",
+    addressCity: "",
+    vatId: "",
+};
+function validateForm(form, messages) {
+    const errors = {};
+    if (!form.companyId)
+        errors.companyId = messages.company;
+    if (!form.name.trim())
+        errors.name = messages.name;
+    if (form.addressZip.trim() && !ZIP_PATTERN.test(form.addressZip.trim())) {
+        errors.addressZip = messages.zip;
+    }
+    if (form.email.trim() && !EMAIL_PATTERN.test(form.email.trim())) {
+        errors.email = messages.email;
+    }
+    return errors;
+}
+export function NewCustomerDialog({ adapter, labels, }) {
+    const companiesQuery = adapter.useCompanies();
+    const companies = companiesQuery.data ?? [];
+    const [open, setOpen] = useState(false);
+    const [form, setForm] = useState(EMPTY_FORM);
+    const [errors, setErrors] = useState({});
+    const [isCreating, setIsCreating] = useState(false);
+    // Clear a field's error as soon as it is edited, not only on the next submit.
+    const setField = (key, value) => {
+        setForm((previous) => ({ ...previous, [key]: value }));
+        setErrors((previous) => (previous[key] ? { ...previous, [key]: "" } : previous));
+    };
+    async function createCustomer() {
+        const foundErrors = validateForm(form, labels.validation);
+        if (Object.keys(foundErrors).length > 0) {
+            setErrors(foundErrors);
+            toast.error(labels.newCustomer.formIncomplete);
+            return;
+        }
+        const cleaned = (value) => (value.trim() === "" ? null : value.trim());
+        setIsCreating(true);
+        try {
+            await adapter.createCustomer({
+                companyId: form.companyId,
+                isCompany: form.isCompany,
+                name: form.name.trim(),
+                contactPerson: cleaned(form.contactPerson),
+                email: cleaned(form.email),
+                phone: cleaned(form.phone),
+                addressStreet: cleaned(form.addressStreet),
+                addressZip: cleaned(form.addressZip),
+                addressCity: cleaned(form.addressCity),
+                vatId: cleaned(form.vatId),
+            });
+            toast.success(labels.newCustomer.created);
+            setForm(EMPTY_FORM);
+            setOpen(false);
+        }
+        catch (error) {
+            toast.error(labels.newCustomer.createFailed(readableErrorMessage(error, "")));
+        }
+        finally {
+            setIsCreating(false);
+        }
+    }
+    return (_jsxs(Dialog, { open: open, onOpenChange: setOpen, children: [_jsx(DialogTrigger, { asChild: true, children: _jsxs(Button, { className: "gap-2", children: [_jsx(Plus, { className: "size-4" }), " ", labels.newCustomer.button] }) }), _jsxs(DialogContent, { children: [_jsxs(DialogHeader, { children: [_jsx(DialogTitle, { children: labels.newCustomer.title }), _jsx(DialogDescription, { children: labels.newCustomer.description })] }), _jsxs("div", { className: "grid gap-3 sm:grid-cols-2", children: [_jsxs("div", { className: "space-y-1 sm:col-span-2", children: [_jsxs(Label, { className: "text-xs text-muted-foreground", children: [labels.fields.company, " ", _jsx(RequiredMark, { title: labels.requiredField })] }), _jsx(Combobox, { value: form.companyId, onValueChange: (value) => setField("companyId", value), options: companies.map((company) => ({
+                                            value: company.id,
+                                            label: `${company.code} · ${company.name}`,
+                                        })), placeholder: labels.newCustomer.companyPlaceholder, invalid: !!errors.companyId }), _jsx(FieldErrorText, { text: errors.companyId })] }), _jsxs("div", { className: "flex items-center gap-2 sm:col-span-2", children: [_jsx(Switch, { checked: form.isCompany, onCheckedChange: (value) => setField("isCompany", value), id: "new-customer-is-company" }), _jsx(Label, { htmlFor: "new-customer-is-company", className: "text-sm font-normal text-muted-foreground", children: labels.newCustomer.isCompany })] }), _jsx(NewCustomerField, { label: labels.fields.name, value: form.name, onChange: (value) => setField("name", value), required: true, requiredTitle: labels.requiredField, error: errors.name, placeholder: labels.examples.name, fullWidth: true }), form.isCompany && (_jsx(NewCustomerField, { label: labels.fields.contactPerson, value: form.contactPerson, onChange: (value) => setField("contactPerson", value), requiredTitle: labels.requiredField, fullWidth: true })), _jsx(NewCustomerField, { label: labels.fields.street, value: form.addressStreet, onChange: (value) => setField("addressStreet", value), requiredTitle: labels.requiredField, error: errors.addressStreet, placeholder: labels.examples.street, fullWidth: true }), _jsx(NewCustomerField, { label: labels.fields.zip, value: form.addressZip, onChange: (value) => setField("addressZip", value), requiredTitle: labels.requiredField, error: errors.addressZip, placeholder: labels.examples.zip }), _jsx(NewCustomerField, { label: labels.fields.city, value: form.addressCity, onChange: (value) => setField("addressCity", value), requiredTitle: labels.requiredField, error: errors.addressCity, placeholder: labels.examples.city }), _jsx(NewCustomerField, { label: labels.fields.vatId, value: form.vatId, onChange: (value) => setField("vatId", value), requiredTitle: labels.requiredField }), _jsx(NewCustomerField, { label: labels.fields.phone, value: form.phone, onChange: (value) => setField("phone", value), requiredTitle: labels.requiredField }), _jsx(NewCustomerField, { label: labels.fields.email, value: form.email, onChange: (value) => setField("email", value), error: errors.email, requiredTitle: labels.requiredField, placeholder: labels.examples.email, fullWidth: true })] }), _jsxs(DialogFooter, { children: [_jsx(Button, { variant: "outline", onClick: () => setOpen(false), children: labels.newCustomer.cancel }), _jsx(Button, { onClick: createCustomer, disabled: isCreating, children: isCreating ? labels.newCustomer.creating : labels.newCustomer.create })] })] })] }));
+}
+function NewCustomerField({ label, value, onChange, fullWidth, required, requiredTitle, error, placeholder, }) {
+    return (_jsxs("div", { className: fullWidth ? "space-y-1 sm:col-span-2" : "space-y-1", children: [_jsxs(Label, { className: "text-xs text-muted-foreground", children: [label, " ", required && _jsx(RequiredMark, { title: requiredTitle })] }), _jsx(Input, { value: value, onChange: (event) => onChange(event.target.value), placeholder: placeholder, "aria-required": required, "aria-invalid": !!error, className: error ? "border-destructive focus-visible:ring-destructive/30" : undefined }), _jsx(FieldErrorText, { text: error })] }));
+}

package/dist/pages/customers/sort-control.d.ts

@@ -0,0 +1,14 @@
+import type { SortDirection } from "./use-table-view";
+import type { CustomersLabels } from "./labels";
+export interface SortColumn {
+    value: string;
+    label: string;
+}
+export declare function SortControl({ columns, sort, direction, onSort, onDirection, labels, }: {
+    columns: SortColumn[];
+    sort: string;
+    direction: SortDirection;
+    onSort: (key: string) => void;
+    onDirection: (direction: SortDirection) => void;
+    labels: CustomersLabels["sort"];
+}): import("react").JSX.Element;

package/dist/pages/customers/sort-control.js

@@ -0,0 +1,9 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Combobox } from "../../ui/combobox.js";
+// Dropdown-based sort control: one field picker plus an ascending/descending picker.
+export function SortControl({ columns, sort, direction, onSort, onDirection, labels, }) {
+    return (_jsxs("div", { className: "flex w-full flex-wrap items-center gap-2 sm:w-auto", children: [_jsx("span", { className: "hidden shrink-0 text-sm text-muted-foreground sm:inline", children: labels.label }), _jsx(Combobox, { value: sort, onValueChange: onSort, className: "w-full sm:w-48", options: columns }), _jsx(Combobox, { value: direction, onValueChange: (value) => onDirection(value), className: "w-full sm:w-40", options: [
+                    { value: "asc", label: labels.ascending },
+                    { value: "desc", label: labels.descending },
+                ] })] }));
+}

package/dist/pages/customers/use-table-view.d.ts

@@ -0,0 +1,23 @@
+export type SortDirection = "asc" | "desc";
+export interface TableView<Row> {
+    pageRows: Row[];
+    sort: string;
+    direction: SortDirection;
+    setSort: (key: string) => void;
+    setDirection: (direction: SortDirection) => void;
+    page: number;
+    setPage: (page: number) => void;
+    pageSize: number;
+    setPageSize: (size: number) => void;
+    total: number;
+    totalPages: number;
+    from: number;
+    to: number;
+}
+export declare function useTableView<Row>(rows: Row[], options: {
+    sortValue: (row: Row, key: string) => string | number;
+    initialSort: string;
+    initialDirection?: SortDirection;
+    initialPageSize?: number;
+    resetKey?: string;
+}): TableView<Row>;

package/dist/pages/customers/use-table-view.js

@@ -0,0 +1,56 @@
+import { useMemo, useState } from "react";
+// Client-side sort + pagination for small lists; `resetKey` returns to page 1 when it changes.
+export function useTableView(rows, options) {
+    const { sortValue, initialSort, initialDirection = "asc", initialPageSize = 25, resetKey, } = options;
+    const [sort, setSortState] = useState(initialSort);
+    const [direction, setDirectionState] = useState(initialDirection);
+    const [page, setPage] = useState(1);
+    const [pageSize, setPageSize] = useState(initialPageSize);
+    // Adjust state during render, so a filter change lands on page 1 without an extra paint.
+    const [seenResetKey, setSeenResetKey] = useState(resetKey);
+    if (resetKey !== seenResetKey) {
+        setSeenResetKey(resetKey);
+        setPage(1);
+    }
+    const sortedRows = useMemo(() => {
+        const copy = [...rows];
+        copy.sort((first, second) => {
+            const firstValue = sortValue(first, sort);
+            const secondValue = sortValue(second, sort);
+            const comparison = typeof firstValue === "number" && typeof secondValue === "number"
+                ? firstValue - secondValue
+                : String(firstValue).localeCompare(String(secondValue));
+            return direction === "asc" ? comparison : -comparison;
+        });
+        return copy;
+    }, [rows, sort, direction, sortValue]);
+    const total = sortedRows.length;
+    const totalPages = Math.max(1, Math.ceil(total / pageSize));
+    const safePage = Math.min(page, totalPages);
+    const from = total === 0 ? 0 : (safePage - 1) * pageSize + 1;
+    const to = Math.min(safePage * pageSize, total);
+    const pageRows = sortedRows.slice((safePage - 1) * pageSize, safePage * pageSize);
+    function setSort(key) {
+        setSortState(key);
+        setPage(1);
+    }
+    function setDirection(next) {
+        setDirectionState(next);
+        setPage(1);
+    }
+    return {
+        pageRows,
+        sort,
+        direction,
+        setSort,
+        setDirection,
+        page: safePage,
+        setPage,
+        pageSize,
+        setPageSize,
+        total,
+        totalPages,
+        from,
+        to,
+    };
+}

package/dist/pages/exclusion-rules/exclusion-rules-page.d.ts

@@ -0,0 +1,7 @@
+import { type ExclusionRulesAdapter } from "../../adapters/exclusion-rules";
+import { type ExclusionRulesLabels } from "./labels";
+export interface ExclusionRulesPageProps {
+    adapter: ExclusionRulesAdapter;
+    labels?: ExclusionRulesLabels;
+}
+export declare function ExclusionRulesPage({ adapter, labels, }: ExclusionRulesPageProps): import("react").JSX.Element;

package/dist/pages/exclusion-rules/exclusion-rules-page.js

@@ -0,0 +1,114 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useEffect, useState } from "react";
+import { AlertTriangle, Plus, Trash2 } from "lucide-react";
+import { toast } from "sonner";
+import { Button } from "../../ui/button.js";
+import { Input } from "../../ui/input.js";
+import { Label } from "../../ui/label.js";
+import { Switch } from "../../ui/switch.js";
+import { Dialog, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogTitle, DialogTrigger, } from "../../ui/dialog.js";
+import { AlertDialog, AlertDialogAction, AlertDialogCancel, AlertDialogContent, AlertDialogDescription, AlertDialogFooter, AlertDialogHeader, AlertDialogTitle, AlertDialogTrigger, } from "../../ui/alert-dialog.js";
+import { Select, SelectContent, SelectGroup, SelectItem, SelectLabel, SelectTrigger, SelectValue, } from "../../ui/select.js";
+import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow, } from "../../ui/table.js";
+import { ErrorState, TableSkeleton, readableErrorMessage, } from "../../components/feedback/query-states.js";
+import { cn } from "../../lib/class-names.js";
+import { EXCLUSION_SCOPES_AFTER_READING, EXCLUSION_SCOPES_BEFORE_READING, } from "../../adapters/exclusion-rules.js";
+import { englishExclusionRulesLabels } from "./labels.js";
+export function ExclusionRulesPage({ adapter, labels = englishExclusionRulesLabels, }) {
+    const rulesQuery = adapter.useExclusionRules();
+    const rules = rulesQuery.data ?? [];
+    return (_jsxs("div", { children: [_jsxs("div", { className: "flex flex-wrap items-end justify-between gap-4", children: [_jsxs("div", { children: [_jsx("h1", { className: "mt-2 text-2xl font-semibold tracking-tight text-foreground", children: labels.title }), _jsx("p", { className: "mt-1 max-w-2xl text-sm text-muted-foreground", children: labels.subtitle })] }), _jsx(NewRuleDialog, { adapter: adapter, labels: labels })] }), rulesQuery.isError ? (_jsx("div", { className: "mt-6", children: _jsx(ErrorState, { error: rulesQuery.error, onRetry: rulesQuery.refetch }) })) : rulesQuery.isLoading ? (_jsx("div", { className: "mt-6", children: _jsx(TableSkeleton, { rows: 5, columns: 4 }) })) : (_jsxs(_Fragment, { children: [_jsx("div", { className: "mt-6 hidden overflow-hidden rounded-xl border border-border bg-card sm:block", children: _jsxs(Table, { children: [_jsx(TableHeader, { children: _jsxs(TableRow, { className: "bg-muted/40", children: [_jsx(TableHead, { children: labels.columns.scope }), _jsx(TableHead, { children: labels.columns.term }), _jsx(TableHead, { children: labels.columns.note }), _jsx(TableHead, { className: "w-[80px] text-center", children: labels.columns.active }), _jsx(TableHead, { className: "w-[64px]" })] }) }), _jsxs(TableBody, { children: [rules.map((rule) => (_jsxs(TableRow, { className: rule.isActive ? "" : "opacity-60", children: [_jsx(TableCell, { children: _jsx(ScopeChip, { scope: rule.scope, labels: labels }) }), _jsx(TableCell, { className: "font-medium text-foreground", children: rule.term }), _jsx(TableCell, { className: "text-sm text-muted-foreground", children: rule.note ?? "—" }), _jsx(TableCell, { className: "text-center", children: _jsx(ActiveToggle, { rule: rule, adapter: adapter, labels: labels }) }), _jsx(TableCell, { children: _jsx("div", { className: "flex justify-end", children: _jsx(DeleteRuleDialog, { rule: rule, adapter: adapter, labels: labels }) }) })] }, rule.id))), rules.length === 0 && (_jsx(TableRow, { children: _jsx(TableCell, { colSpan: 5, className: "py-12 text-center text-muted-foreground", children: labels.empty }) }))] })] }) }), _jsxs("div", { className: "mt-6 space-y-3 sm:hidden", children: [rules.map((rule) => (_jsxs("div", { className: cn("rounded-xl border border-border bg-card p-4", !rule.isActive && "opacity-60"), children: [_jsxs("div", { className: "flex items-start justify-between gap-3", children: [_jsxs("div", { className: "min-w-0", children: [_jsx(ScopeChip, { scope: rule.scope, labels: labels }), _jsx("div", { className: "mt-1 font-medium text-foreground", children: rule.term })] }), _jsx("div", { className: "shrink-0", children: _jsx(DeleteRuleDialog, { rule: rule, adapter: adapter, labels: labels }) })] }), rule.note && _jsx("p", { className: "mt-2 text-sm text-muted-foreground", children: rule.note }), _jsxs("div", { className: "mt-3 flex items-center justify-between border-t border-border pt-2", children: [_jsx("span", { className: "text-xs text-muted-foreground", children: labels.columns.active }), _jsx(ActiveToggle, { rule: rule, adapter: adapter, labels: labels })] })] }, rule.id))), rules.length === 0 && (_jsx("p", { className: "rounded-xl border border-border bg-card px-4 py-12 text-center text-sm text-muted-foreground", children: labels.empty }))] })] }))] }));
+}
+function ScopeChip({ scope, labels }) {
+    return (_jsx("span", { className: "inline-flex rounded-md bg-muted px-2 py-0.5 text-xs font-medium text-foreground", children: labels.scopeNames[scope] }));
+}
+function ActiveToggle({ rule, adapter, labels, }) {
+    const [isSaving, setIsSaving] = useState(false);
+    async function toggle(nextActive) {
+        setIsSaving(true);
+        try {
+            await adapter.setExclusionRuleActive({ id: rule.id, isActive: nextActive });
+            toast.success(nextActive ? labels.toggle.activated : labels.toggle.deactivated);
+        }
+        catch (error) {
+            toast.error(labels.toggle.failed(readableErrorMessage(error, "")));
+        }
+        finally {
+            setIsSaving(false);
+        }
+    }
+    return (_jsx(Switch, { checked: rule.isActive, disabled: isSaving, "aria-label": labels.columns.active, onCheckedChange: toggle }));
+}
+// Waits after the last keystroke so the impact check is not fired per keystroke.
+function useDebouncedValue(value, delayMs) {
+    const [debounced, setDebounced] = useState(value);
+    useEffect(() => {
+        const timer = window.setTimeout(() => setDebounced(value), delayMs);
+        return () => window.clearTimeout(timer);
+    }, [value, delayMs]);
+    return debounced;
+}
+// A failed check is shown as failed, never folded into "0 matches" — that would be a
+// confident lie about a rule that silently drops mail.
+function ImpactPreview({ impact, term, labels, }) {
+    if (term.trim().length < 2)
+        return null;
+    if (impact.isLoading) {
+        return _jsx("p", { className: "text-xs text-muted-foreground", children: labels.impactPreview.checking });
+    }
+    if (impact.isError) {
+        return _jsx("p", { className: "text-xs text-muted-foreground", children: labels.impactPreview.failed });
+    }
+    if (!impact.data || !impact.data.supported) {
+        return _jsx("p", { className: "text-xs text-muted-foreground", children: labels.impactPreview.notAvailable });
+    }
+    const { matchCount, totalCount } = impact.data;
+    const share = totalCount > 0 ? (matchCount / totalCount) * 100 : 0;
+    // A rule that catches a large share of everything ever seen is the mistake this preview exists for.
+    const isBroad = matchCount > 0 && share >= 20;
+    return (_jsxs("p", { className: cn("flex items-start gap-1.5 text-xs", isBroad ? "text-warning" : "text-muted-foreground"), children: [isBroad && _jsx(AlertTriangle, { className: "mt-0.5 size-3 shrink-0" }), matchCount === 0
+                ? labels.impactPreview.noMatches(totalCount)
+                : labels.impactPreview.matches(matchCount, totalCount, share.toFixed(share < 10 ? 1 : 0))] }));
+}
+function NewRuleDialog({ adapter, labels, }) {
+    const [open, setOpen] = useState(false);
+    const [scope, setScope] = useState("subject");
+    const [term, setTerm] = useState("");
+    const [note, setNote] = useState("");
+    const [isSaving, setIsSaving] = useState(false);
+    const debouncedTerm = useDebouncedValue(term, 400);
+    const impact = adapter.useExclusionImpact({ scope, term: debouncedTerm, enabled: open });
+    async function createRule() {
+        if (!term.trim()) {
+            toast.error(labels.dialog.termRequired);
+            return;
+        }
+        setIsSaving(true);
+        try {
+            await adapter.createExclusionRule({ scope, term, note });
+            toast.success(labels.dialog.created);
+            setTerm("");
+            setNote("");
+            setOpen(false);
+        }
+        catch (error) {
+            toast.error(labels.dialog.createFailed(readableErrorMessage(error, "")));
+        }
+        finally {
+            setIsSaving(false);
+        }
+    }
+    return (_jsxs(Dialog, { open: open, onOpenChange: setOpen, children: [_jsx(DialogTrigger, { asChild: true, children: _jsxs(Button, { className: "gap-2", children: [_jsx(Plus, { className: "size-4" }), " ", labels.newRuleButton] }) }), _jsxs(DialogContent, { children: [_jsxs(DialogHeader, { children: [_jsx(DialogTitle, { children: labels.dialog.title }), _jsx(DialogDescription, { children: labels.dialog.description })] }), _jsxs("div", { className: "grid gap-3", children: [_jsxs("div", { className: "space-y-1", children: [_jsx(Label, { className: "text-xs text-muted-foreground", children: labels.dialog.scopeField }), _jsxs(Select, { value: scope, onValueChange: (value) => setScope(value), children: [_jsx(SelectTrigger, { children: _jsx(SelectValue, {}) }), _jsxs(SelectContent, { children: [_jsxs(SelectGroup, { children: [_jsx(SelectLabel, { children: labels.scopeGroupBeforeReading }), EXCLUSION_SCOPES_BEFORE_READING.map((scopeValue) => (_jsx(SelectItem, { value: scopeValue, children: labels.scopeNames[scopeValue] }, scopeValue)))] }), _jsxs(SelectGroup, { children: [_jsx(SelectLabel, { children: labels.scopeGroupAfterReading }), EXCLUSION_SCOPES_AFTER_READING.map((scopeValue) => (_jsx(SelectItem, { value: scopeValue, children: labels.scopeNames[scopeValue] }, scopeValue)))] })] })] })] }), _jsxs("div", { className: "space-y-1", children: [_jsx(Label, { className: "text-xs text-muted-foreground", children: labels.dialog.termField }), _jsx(Input, { value: term, onChange: (event) => setTerm(event.target.value), placeholder: labels.dialog.termPlaceholder }), _jsx(ImpactPreview, { impact: impact, term: debouncedTerm, labels: labels })] }), _jsxs("div", { className: "space-y-1", children: [_jsx(Label, { className: "text-xs text-muted-foreground", children: labels.dialog.noteField }), _jsx(Input, { value: note, onChange: (event) => setNote(event.target.value), placeholder: labels.dialog.notePlaceholder })] })] }), _jsxs(DialogFooter, { children: [_jsx(Button, { variant: "outline", onClick: () => setOpen(false), children: labels.dialog.cancel }), _jsx(Button, { onClick: createRule, disabled: isSaving || !term.trim(), children: isSaving ? labels.dialog.saving : labels.dialog.save })] })] })] }));
+}
+function DeleteRuleDialog({ rule, adapter, labels, }) {
+    async function deleteRule() {
+        try {
+            await adapter.deleteExclusionRule(rule.id);
+            toast.success(labels.deleteDialog.deleted);
+        }
+        catch (error) {
+            toast.error(labels.deleteDialog.failed(readableErrorMessage(error, "")));
+        }
+    }
+    return (_jsxs(AlertDialog, { children: [_jsx(AlertDialogTrigger, { asChild: true, children: _jsx(Button, { variant: "ghost", size: "icon", className: "text-destructive hover:bg-destructive/10 hover:text-destructive", "aria-label": labels.deleteDialog.openButton, children: _jsx(Trash2, { className: "size-4" }) }) }), _jsxs(AlertDialogContent, { children: [_jsxs(AlertDialogHeader, { children: [_jsx(AlertDialogTitle, { children: labels.deleteDialog.title }), _jsx(AlertDialogDescription, { children: labels.deleteDialog.description(rule.term, labels.scopeNames[rule.scope]) })] }), _jsxs(AlertDialogFooter, { children: [_jsx(AlertDialogCancel, { children: labels.deleteDialog.cancel }), _jsx(AlertDialogAction, { onClick: deleteRule, className: "bg-destructive text-destructive-foreground hover:bg-destructive/90", children: labels.deleteDialog.confirm })] })] })] }));
+}

package/dist/pages/exclusion-rules/labels.d.ts

@@ -0,0 +1,53 @@
+import type { ExclusionScope } from "../../adapters/exclusion-rules";
+export interface ExclusionRulesLabels {
+    title: string;
+    subtitle: string;
+    newRuleButton: string;
+    empty: string;
+    columns: {
+        scope: string;
+        term: string;
+        note: string;
+        active: string;
+    };
+    scopeNames: Record<ExclusionScope, string>;
+    scopeGroupBeforeReading: string;
+    scopeGroupAfterReading: string;
+    dialog: {
+        title: string;
+        description: string;
+        scopeField: string;
+        termField: string;
+        termPlaceholder: string;
+        noteField: string;
+        notePlaceholder: string;
+        cancel: string;
+        save: string;
+        saving: string;
+        termRequired: string;
+        created: string;
+        createFailed: (error: string) => string;
+    };
+    toggle: {
+        activated: string;
+        deactivated: string;
+        failed: (error: string) => string;
+    };
+    deleteDialog: {
+        openButton: string;
+        title: string;
+        description: (term: string, scopeName: string) => string;
+        cancel: string;
+        confirm: string;
+        deleted: string;
+        failed: (error: string) => string;
+    };
+    impactPreview: {
+        checking: string;
+        failed: string;
+        notAvailable: string;
+        noMatches: (total: number) => string;
+        matches: (count: number, total: number, percentText: string) => string;
+    };
+}
+export declare const englishExclusionRulesLabels: ExclusionRulesLabels;

package/dist/pages/exclusion-rules/labels.js

@@ -0,0 +1,61 @@
+export const englishExclusionRulesLabels = {
+    title: "Exclusion rules",
+    subtitle: "Incoming mails and files that match one of these rules are skipped by the pipeline and never become invoices.",
+    newRuleButton: "New rule",
+    empty: "No exclusion rules yet.",
+    columns: {
+        scope: "Scope",
+        term: "Term",
+        note: "Note",
+        active: "Active",
+    },
+    scopeNames: {
+        sender: "Sender",
+        subject: "Subject",
+        filename: "File name",
+        envelope: "Entire envelope",
+        party: "Party",
+        supplier: "Supplier",
+        body: "Document text",
+        company: "Company",
+        property: "Property",
+    },
+    scopeGroupBeforeReading: "Before reading (mail envelope)",
+    scopeGroupAfterReading: "After reading (extracted fields)",
+    dialog: {
+        title: "New exclusion rule",
+        description: "Mails or documents that match this rule are excluded from processing.",
+        scopeField: "Scope",
+        termField: "Term",
+        termPlaceholder: "e.g. newsletter@",
+        noteField: "Note (optional)",
+        notePlaceholder: "Why this rule exists",
+        cancel: "Cancel",
+        save: "Create rule",
+        saving: "Creating …",
+        termRequired: "Please enter a term.",
+        created: "Exclusion rule created.",
+        createFailed: (error) => `Creating the rule failed: ${error}`,
+    },
+    toggle: {
+        activated: "Rule activated.",
+        deactivated: "Rule deactivated.",
+        failed: (error) => `Updating the rule failed: ${error}`,
+    },
+    deleteDialog: {
+        openButton: "Delete rule",
+        title: "Delete this rule?",
+        description: (term, scopeName) => `The rule "${term}" (${scopeName}) will be removed. Future mails matching it will be processed again.`,
+        cancel: "Cancel",
+        confirm: "Delete",
+        deleted: "Exclusion rule deleted.",
+        failed: (error) => `Deleting the rule failed: ${error}`,
+    },
+    impactPreview: {
+        checking: "Checking past entries …",
+        failed: "The impact check is not available right now.",
+        notAvailable: "There is no historical data to check this scope against.",
+        noMatches: (total) => `No matches among ${total} past entries.`,
+        matches: (count, total, percentText) => `Would have matched ${count} of ${total} past entries (${percentText}%).`,
+    },
+};

package/dist/pages/file-naming/build-filename.d.ts

@@ -0,0 +1,3 @@
+import type { FileNamingSettingsInput, FilenamePreviewInvoice } from "../../adapters/file-naming";
+export declare const UNSAFE_FILENAME_CHARS: RegExp;
+export declare function buildSuggestedFilename(invoice: FilenamePreviewInvoice, settings: FileNamingSettingsInput, extension?: string): string | null;

package/dist/pages/file-naming/build-filename.js

@@ -0,0 +1,82 @@
+// Builds the uniform filename pattern for an invoice:
+//   YYYYMMDD COM[_VAT] Issuer Description [Amount] [Property]
+// The document type is deliberately never included — it is implied by the destination folder.
+const UMLAUT_MAP = {
+    ä: "ae",
+    ö: "oe",
+    ü: "ue",
+    Ä: "Ae",
+    Ö: "Oe",
+    Ü: "Ue",
+    ß: "ss",
+};
+// Filesystem/URL-unsafe characters, stripped from every segment and the joined name.
+export const UNSAFE_FILENAME_CHARS = /[\\/:*?"<>|]/;
+const UNSAFE_FILENAME_CHARS_GLOBAL = new RegExp(UNSAFE_FILENAME_CHARS.source, "g");
+// Download-filename validation rejects anything over 255 characters, so the cap lives here.
+const MAX_FILENAME_LENGTH = 255;
+function transliterateUmlauts(input) {
+    return input.replace(/[äöüÄÖÜß]/g, (character) => UMLAUT_MAP[character] ?? character);
+}
+function sanitizeSegment(input) {
+    return input.replace(UNSAFE_FILENAME_CHARS_GLOBAL, "").trim();
+}
+function formatDateSegment(isoDate) {
+    if (!isoDate)
+        return null;
+    const digits = isoDate.slice(0, 10).replaceAll("-", "");
+    return digits.length === 8 ? digits : null;
+}
+function formatAmountSegment(amount) {
+    if (amount == null)
+        return null;
+    return amount.toLocaleString("de-DE", { minimumFractionDigits: 2, maximumFractionDigits: 2 });
+}
+// "VAT-relevant" for the VAT suffix: a positive VAT rate that is not explicitly tax-exempt.
+function isVatRelevant(invoice) {
+    return (invoice.vatRate ?? 0) > 0 && !invoice.vatExempt;
+}
+function descriptionFor(invoice, source) {
+    if (source === "service_description")
+        return invoice.serviceDescription;
+    if (source === "cost_category")
+        return invoice.costCategory;
+    return null;
+}
+// Returns null when there is not enough data to build a meaningful name, so callers can
+// fall back to the original filename instead.
+export function buildSuggestedFilename(invoice, settings, extension = "pdf") {
+    const parts = [];
+    const date = formatDateSegment(invoice.documentDate);
+    if (date)
+        parts.push(date);
+    if (invoice.companyCode) {
+        const vatSuffix = settings.includeVatSuffix && isVatRelevant(invoice) ? `_${settings.vatSuffix}` : "";
+        parts.push(`${invoice.companyCode}${vatSuffix}`);
+    }
+    if (invoice.issuer)
+        parts.push(sanitizeSegment(invoice.issuer));
+    const description = descriptionFor(invoice, settings.descriptionSource);
+    if (description)
+        parts.push(sanitizeSegment(description));
+    if (settings.includeAmount) {
+        const amount = formatAmountSegment(invoice.amountGross);
+        if (amount)
+            parts.push(amount);
+    }
+    if (settings.includeProperty && invoice.propertyCode) {
+        parts.push(sanitizeSegment(invoice.propertyCode));
+    }
+    if (parts.length === 0)
+        return null;
+    let name = parts.join(settings.separator);
+    if (settings.transliterateUmlauts)
+        name = transliterateUmlauts(name);
+    name = sanitizeSegment(name);
+    // Truncate the name, never the extension — a cut-off ".pdf" breaks the download entirely.
+    const maxNameLength = MAX_FILENAME_LENGTH - extension.length - 1;
+    if (name.length > maxNameLength) {
+        name = sanitizeSegment(name.slice(0, maxNameLength));
+    }
+    return `${name}.${extension}`;
+}

package/dist/pages/file-naming/file-naming-page.d.ts

@@ -0,0 +1,10 @@
+import { type Formatters } from "../../lib/formatters";
+import type { FileNamingAdapter } from "../../adapters/file-naming";
+import { type FileNamingLabels } from "./labels";
+export interface FileNamingPageProps {
+    adapter: FileNamingAdapter;
+    canEdit: boolean;
+    labels?: FileNamingLabels;
+    formatters?: Formatters;
+}
+export declare function FileNamingPage({ adapter, canEdit, labels, formatters, }: FileNamingPageProps): import("react").JSX.Element;