@spaceinvoices/react-ui 0.4.10 → 0.4.12

package/src/components/documents/create/payment-rows.ts

@@ -0,0 +1,291 @@
+import type { PriceModesMap } from "./document-items-section";
+
+export const REGULAR_PAYMENT_TYPES = ["cash", "bank_transfer", "card", "check", "other"] as const;
+
+export type RegularPaymentType = (typeof REGULAR_PAYMENT_TYPES)[number];
+
+export type DraftPaymentRow = {
+  id?: string;
+  type: RegularPaymentType | null;
+  amount: string;
+  amountTouched: boolean;
+};
+
+export type SerializedPaymentRow = {
+  type: RegularPaymentType;
+  amount: number;
+};
+
+export type PaymentRowsEvaluation = {
+  payments: SerializedPaymentRow[];
+  totalAmount: number;
+  hasTypeError: boolean;
+  hasAmountError: boolean;
+  exceedsTotal: boolean;
+  requiresFullAmount: boolean;
+  totalMatchesExactly: boolean;
+};
+
+export type PaymentRowsValidationMode = "partial_allowed" | "full_required";
+
+export type PaymentRowsValidation = {
+  typeError?: string;
+  amountError?: string;
+  totalError?: string;
+  payments: SerializedPaymentRow[];
+  totalAmount: number;
+};
+
+export function getPaymentValidationMessage(
+  evaluation: PaymentRowsEvaluation,
+  options?: { requireFullAmount?: boolean },
+): string | undefined {
+  if (evaluation.hasTypeError) {
+    return "Please select a payment type";
+  }
+
+  if (evaluation.exceedsTotal) {
+    return "Payment amounts cannot exceed the document total";
+  }
+
+  if (options?.requireFullAmount && !evaluation.totalMatchesExactly) {
+    return "Advance invoices must be fully paid";
+  }
+
+  if (evaluation.hasAmountError) {
+    return "Payment amount must be greater than 0";
+  }
+
+  return undefined;
+}
+
+export function getFirstValidPaymentType(paymentRows: DraftPaymentRow[]): RegularPaymentType | undefined {
+  return paymentRows.find((row) => isValidPaymentTypeSelection(row.type))?.type ?? undefined;
+}
+
+export function createEmptyPaymentRow(): DraftPaymentRow {
+  return { id: crypto.randomUUID(), type: null, amount: "", amountTouched: false };
+}
+
+export function coercePaymentRowsToType(paymentRows: DraftPaymentRow[], type: RegularPaymentType): DraftPaymentRow[] {
+  if (paymentRows.length === 0) {
+    return [{ ...createEmptyPaymentRow(), type }];
+  }
+
+  return paymentRows.map((row) => ({
+    ...row,
+    type,
+  }));
+}
+
+export function isValidPaymentTypeSelection(value: string | null | undefined): value is RegularPaymentType {
+  return REGULAR_PAYMENT_TYPES.includes(value as RegularPaymentType);
+}
+
+export function roundCurrency(amount: number): number {
+  return Math.round((amount + Number.EPSILON) * 100) / 100;
+}
+
+export function formatAmountInput(amount: number | null): string {
+  if (amount == null || !Number.isFinite(amount)) return "";
+  return amount.toFixed(2);
+}
+
+export function parsePaymentAmount(value: string): number | null {
+  const trimmed = value.trim();
+  if (!trimmed) return null;
+
+  const normalized = trimmed.replace(",", ".");
+  const parsed = Number(normalized);
+  if (!Number.isFinite(parsed)) return null;
+
+  return roundCurrency(parsed);
+}
+
+export function calculateDocumentTotal(items: any[] | undefined, priceModes: PriceModesMap = {}): number {
+  if (!items?.length) return 0;
+
+  const total = items.reduce((sum, item, index) => {
+    if (!item || item.type === "separator") return sum;
+
+    const quantity = Number(item.quantity ?? 0);
+    const price = Number(item.price ?? 0);
+    if (!Number.isFinite(quantity) || !Number.isFinite(price) || quantity <= 0 || price <= 0) {
+      return sum;
+    }
+
+    const lineBase = quantity * price;
+    const isGrossPrice = priceModes[index] ?? false;
+    const taxMultiplier =
+      1 +
+      (Array.isArray(item.taxes)
+        ? item.taxes.reduce((taxSum: number, tax: any) => taxSum + Number(tax?.rate ?? 0), 0) / 100
+        : 0);
+
+    return sum + (isGrossPrice ? lineBase : lineBase * taxMultiplier);
+  }, 0);
+
+  return roundCurrency(total);
+}
+
+export function derivePaymentAmounts(paymentRows: DraftPaymentRow[], documentTotal: number): Array<number | null> {
+  const resolved = Array<number | null>(paymentRows.length).fill(null);
+  const untouchedIndexes: number[] = [];
+  let touchedTotal = 0;
+
+  paymentRows.forEach((row, index) => {
+    if (!row.amountTouched) {
+      untouchedIndexes.push(index);
+      return;
+    }
+
+    const parsed = parsePaymentAmount(row.amount);
+    resolved[index] = parsed;
+    if (parsed != null) {
+      touchedTotal += parsed;
+    }
+  });
+
+  const roundedTotal = roundCurrency(documentTotal);
+  const remaining = roundCurrency(roundedTotal - touchedTotal);
+
+  if (untouchedIndexes.length === 0) {
+    return resolved;
+  }
+
+  if (remaining <= 0) {
+    untouchedIndexes.forEach((index) => {
+      resolved[index] = 0;
+    });
+    return resolved;
+  }
+
+  const equalShare = roundCurrency(remaining / untouchedIndexes.length);
+  let allocated = 0;
+
+  untouchedIndexes.forEach((index, arrayIndex) => {
+    if (arrayIndex === untouchedIndexes.length - 1) {
+      resolved[index] = roundCurrency(remaining - allocated);
+      return;
+    }
+
+    resolved[index] = equalShare;
+    allocated = roundCurrency(allocated + equalShare);
+  });
+
+  return resolved;
+}
+
+export const derivePaymentRowAmounts = derivePaymentAmounts;
+
+export function getDisplayPaymentAmount(row: DraftPaymentRow, derivedAmount: number | null): string {
+  return row.amountTouched ? row.amount : formatAmountInput(derivedAmount);
+}
+
+export function getRecordedPaymentTotal(paymentRows: DraftPaymentRow[], documentTotal: number): number {
+  const resolvedAmounts = derivePaymentAmounts(paymentRows, documentTotal);
+  return roundCurrency(
+    resolvedAmounts.reduce<number>((sum, amount) => sum + (amount != null && amount > 0 ? amount : 0), 0),
+  );
+}
+
+export function evaluatePaymentRows(
+  paymentRows: DraftPaymentRow[],
+  documentTotal: number,
+  options?: { requireFullAmount?: boolean },
+): PaymentRowsEvaluation {
+  const resolvedAmounts = derivePaymentAmounts(paymentRows, documentTotal);
+  const payments: SerializedPaymentRow[] = [];
+  let hasTypeError = false;
+  let hasAmountError = false;
+
+  paymentRows.forEach((row, index) => {
+    if (!isValidPaymentTypeSelection(row.type)) {
+      hasTypeError = true;
+      return;
+    }
+
+    const amount = resolvedAmounts[index];
+    if (amount == null || amount <= 0) {
+      hasAmountError = true;
+      return;
+    }
+
+    payments.push({ type: row.type, amount });
+  });
+
+  const totalAmount = roundCurrency(payments.reduce((sum, payment) => sum + payment.amount, 0));
+  const roundedTotal = roundCurrency(documentTotal);
+  const exceedsTotal = totalAmount > roundedTotal;
+  const requireFullAmount = options?.requireFullAmount === true;
+  const totalMatchesExactly = totalAmount === roundedTotal;
+
+  if (exceedsTotal) {
+    hasAmountError = true;
+  }
+
+  if (requireFullAmount && !totalMatchesExactly) {
+    hasAmountError = true;
+  }
+
+  return {
+    payments,
+    totalAmount,
+    hasTypeError,
+    hasAmountError,
+    exceedsTotal,
+    requiresFullAmount: requireFullAmount,
+    totalMatchesExactly,
+  };
+}
+
+export function validatePaymentRows(
+  paymentRows: DraftPaymentRow[],
+  documentTotal: number,
+  mode: PaymentRowsValidationMode,
+): PaymentRowsValidation {
+  const evaluation = evaluatePaymentRows(paymentRows, documentTotal, {
+    requireFullAmount: mode === "full_required",
+  });
+
+  if (evaluation.hasTypeError) {
+    return {
+      payments: evaluation.payments,
+      totalAmount: evaluation.totalAmount,
+      typeError: "Please select a payment type",
+    };
+  }
+
+  if (evaluation.exceedsTotal) {
+    return {
+      payments: evaluation.payments,
+      totalAmount: evaluation.totalAmount,
+      totalError: "Payment amounts cannot exceed the document total",
+    };
+  }
+
+  if (mode === "full_required" && !evaluation.totalMatchesExactly) {
+    return {
+      payments: evaluation.payments,
+      totalAmount: evaluation.totalAmount,
+      totalError: "Advance invoices must be fully paid",
+    };
+  }
+
+  if (evaluation.hasAmountError) {
+    return {
+      payments: evaluation.payments,
+      totalAmount: evaluation.totalAmount,
+      amountError: "Payment amount must be greater than 0",
+    };
+  }
+
+  return {
+    payments: evaluation.payments,
+    totalAmount: evaluation.totalAmount,
+  };
+}
+
+export function serializePaymentRows(paymentRows: DraftPaymentRow[], documentTotal: number): SerializedPaymentRow[] {
+  return evaluatePaymentRows(paymentRows, documentTotal).payments;
+}

package/src/components/documents/create/prepare-document-submission.ts

@@ -33,6 +33,8 @@ type PrepareDocumentOptions = {
   markAsPaid?: boolean;
   /** For invoices/credit notes: payment types when markAsPaid is true */
   paymentTypes?: string[];
+  /** Structured payments when amounts were already normalized by the form layer */
+  payments?: Array<{ type: string; amount?: number }>;
   /** Document type for specific date handling */
   documentType: "invoice" | "estimate" | "credit_note" | "advance_invoice" | "delivery_note";
   /** Secondary date field value (date_due for invoices, date_valid_till for estimates) */
@@ -157,8 +159,12 @@ export function prepareDocumentSubmission<T extends BaseDocumentValues>(
         taxes: item.taxes
           ?.map((tax: any) => {
             if (tax.tax_id) {
-              // Only send tax_id, API will resolve the rate
-              return { tax_id: tax.tax_id };
+              // Preserve PT exemption metadata while still allowing the API to resolve the tax rate by tax_id.
+              return {
+                tax_id: tax.tax_id,
+                ...(tax.pt_exemption_code ? { pt_exemption_code: tax.pt_exemption_code } : {}),
+                ...(tax.pt_exemption_reason ? { pt_exemption_reason: tax.pt_exemption_reason } : {}),
+              };
             }
             return tax;
           })
@@ -170,7 +176,7 @@ export function prepareDocumentSubmission<T extends BaseDocumentValues>(
 
   // Build payload with date conversions
   // Destructure to exclude fields we handle explicitly (number is always server-generated)
-  const { number: _number, note, payment_terms, reference, signature, ...restValues } = nextValues as any;
+  const { number: _number, note, payment_terms, reference, signature, pt: _pt, ...restValues } = nextValues as any;
   const payload: any = {
     ...restValues,
     ...(note?.trim() && { note: note.trim() }),
@@ -201,16 +207,21 @@ export function prepareDocumentSubmission<T extends BaseDocumentValues>(
   }
 
   // Handle markAsPaid for invoices and credit notes
-  if (
-    options.documentType !== "estimate" &&
-    options.markAsPaid &&
-    options.paymentTypes &&
-    options.paymentTypes.length > 0
-  ) {
-    payload.payments = options.paymentTypes.map((type: string) => ({
-      type,
-      date: payload.date ?? undefined,
-    }));
+  if (options.documentType !== "estimate" && options.markAsPaid) {
+    const serializedPayments =
+      options.payments?.map((payment) => ({
+        ...payment,
+        date: payload.date ?? undefined,
+      })) ??
+      options.paymentTypes?.map((type: string) => ({
+        type,
+        date: payload.date ?? undefined,
+      })) ??
+      [];
+
+    if (serializedPayments.length > 0) {
+      payload.payments = serializedPayments;
+    }
   }
 
   // Remove UI-only fields from payload

package/src/components/documents/create/scroll-to-first-invalid-field.ts

@@ -0,0 +1,27 @@
+export function scrollToFirstInvalidField(formId: string) {
+  if (typeof document === "undefined") {
+    return;
+  }
+
+  const form = document.getElementById(formId);
+  if (!form) {
+    return;
+  }
+
+  const scrollToInvalidField = () => {
+    const errorTarget = form.querySelector<HTMLElement>('[data-form-error-summary="true"], [aria-invalid="true"]');
+    if (!errorTarget) {
+      return;
+    }
+
+    errorTarget.scrollIntoView({ behavior: "smooth", block: "center" });
+
+    if (errorTarget.matches('[aria-invalid="true"]') && typeof errorTarget.focus === "function") {
+      errorTarget.focus({ preventScroll: true });
+    }
+  };
+
+  requestAnimationFrame(() => {
+    requestAnimationFrame(scrollToInvalidField);
+  });
+}

package/src/components/documents/create/smart-code-insert-button.tsx

@@ -15,56 +15,7 @@ import {
   DropdownMenuTrigger,
 } from "@/ui/components/ui/dropdown-menu";
 import { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger } from "@/ui/components/ui/tooltip";
-
-const TEMPLATE_VARIABLES = [
-  {
-    category: "Entity",
-    variables: [
-      { code: "{entity_name}", label: "Company name" },
-      { code: "{entity_email}", label: "Email address" },
-      { code: "{entity_address}", label: "Address" },
-      { code: "{entity_post_code}", label: "Post code" },
-      { code: "{entity_city}", label: "City" },
-      { code: "{entity_country}", label: "Country" },
-      { code: "{entity_tax_number}", label: "Tax number" },
-      { code: "{entity_company_number}", label: "Company number" },
-    ],
-  },
-  {
-    category: "Document",
-    variables: [
-      { code: "{document_number}", label: "Invoice number" },
-      { code: "{document_date}", label: "Invoice date" },
-      { code: "{document_due_date}", label: "Due date" },
-      { code: "{document_total}", label: "Total amount" },
-      { code: "{document_currency}", label: "Currency" },
-    ],
-  },
-  {
-    category: "Customer",
-    variables: [
-      { code: "{customer_name}", label: "Customer name" },
-      { code: "{customer_email}", label: "Customer email" },
-    ],
-  },
-  {
-    category: "Bank Account",
-    variables: [
-      { code: "{bank_account}", label: "Full account info" },
-      { code: "{bank_account.iban}", label: "IBAN" },
-      { code: "{bank_account.bank_name}", label: "Bank name" },
-      { code: "{bank_account.bic}", label: "BIC/SWIFT" },
-      { code: "{bank_account.account_number}", label: "Account number" },
-    ],
-  },
-  {
-    category: "Other",
-    variables: [
-      { code: "{current_date}", label: "Today's date" },
-      { code: "{current_year}", label: "Current year" },
-    ],
-  },
-];
+import { getTemplateVariableGroups } from "@/ui/lib/template-variables";
 
 interface SmartCodeInsertButtonProps {
   /** Reference to the textarea element */
@@ -80,6 +31,7 @@ interface SmartCodeInsertButtonProps {
 export function SmartCodeInsertButton({ textareaRef, onInsert, value, t }: SmartCodeInsertButtonProps) {
   // Store cursor position for when textarea loses focus before dropdown opens
   const cursorPositionRef = useRef<number>(0);
+  const templateVariables = getTemplateVariableGroups(t);
 
   const insertVariable = useCallback(
     (code: string) => {
@@ -121,10 +73,10 @@ export function SmartCodeInsertButton({ textareaRef, onInsert, value, t }: Smart
         </Tooltip>
       </TooltipProvider>
       <DropdownMenuContent align="end" className="w-72">
-        {TEMPLATE_VARIABLES.map((group, groupIndex) => (
+        {templateVariables.map((group, groupIndex) => (
           <div key={group.category}>
             {groupIndex > 0 && <DropdownMenuSeparator />}
-            <DropdownMenuLabel className="text-muted-foreground text-xs">{t(group.category)}</DropdownMenuLabel>
+            <DropdownMenuLabel className="text-muted-foreground text-xs">{group.category}</DropdownMenuLabel>
             <DropdownMenuGroup>
               {group.variables.map((variable) => (
                 <DropdownMenuItem
@@ -133,7 +85,7 @@ export function SmartCodeInsertButton({ textareaRef, onInsert, value, t }: Smart
                   className="flex cursor-pointer items-center whitespace-nowrap"
                 >
                   <code className="mr-2 shrink-0 rounded bg-muted px-1 py-0.5 font-mono text-xs">{variable.code}</code>
-                  <span className="text-muted-foreground text-xs">{t(variable.label)}</span>
+                  <span className="text-muted-foreground text-xs">{variable.label}</span>
                 </DropdownMenuItem>
               ))}
             </DropdownMenuGroup>

package/src/components/documents/create/use-document-customer-form.ts

@@ -26,17 +26,6 @@ export type DocumentFormWithCustomer = FieldValues & {
   customer?: CustomerData | null;
 };
 
-/**
- * Type-safe setValue wrapper for document forms.
- */
-function _setFormValue<TForm extends FieldValues>(
-  form: UseFormReturn<TForm>,
-  name: Path<TForm>,
-  value: PathValue<TForm, Path<TForm>>,
-) {
-  form.setValue(name, value);
-}
-
 /**
  * Shared hook for managing customer selection and form state in document forms.
  * Used by invoices, estimates, credit notes, and advance invoices.
@@ -85,6 +74,20 @@ export function useDocumentCustomerForm<TForm extends DocumentFormWithCustomer>(
 
   const handleCustomerSelect = (customerId: string, customer: CustomerData) => {
     const isNewCustomer = !customerId || customerId === "";
+    const customerFieldPaths = [
+      "customer.name",
+      "customer.address",
+      "customer.address_2",
+      "customer.post_code",
+      "customer.city",
+      "customer.state",
+      "customer.country",
+      "customer.tax_number",
+      "customer.is_end_consumer",
+    ] as Path<TForm>[];
+    const setCustomerFieldValue = <K extends Path<TForm>>(name: K, value: PathValue<TForm, K>) => {
+      form.setValue(name, value, { shouldDirty: true, shouldTouch: true, shouldValidate: true });
+    };
 
     // Helper to convert empty/null to undefined for optional fields,
     // but keep empty string for required fields (name) so form shows them
@@ -98,19 +101,41 @@ export function useDocumentCustomerForm<TForm extends DocumentFormWithCustomer>(
     if (isNewCustomer) {
       // New customer - clear customer_id and set customer data
       setValue("customer_id" as Path<TForm>, undefined as PathValue<TForm, Path<TForm>>);
-      setValue(
-        "customer" as Path<TForm>,
-        {
-          name: toFormValue(customer.name, true),
-          address: toFormValue(customer.address),
-          address_2: toFormValue(customer.address_2),
-          post_code: toFormValue(customer.post_code),
-          city: toFormValue(customer.city),
-          state: toFormValue(customer.state),
-          country: toFormValue(customer.country),
-          tax_number: toFormValue(customer.tax_number),
-          is_end_consumer: customer.is_end_consumer ?? undefined,
-        } as PathValue<TForm, Path<TForm>>,
+      setCustomerFieldValue(
+        "customer.name" as Path<TForm>,
+        toFormValue(customer.name, true) as PathValue<TForm, Path<TForm>>,
+      );
+      setCustomerFieldValue(
+        "customer.address" as Path<TForm>,
+        toFormValue(customer.address) as PathValue<TForm, Path<TForm>>,
+      );
+      setCustomerFieldValue(
+        "customer.address_2" as Path<TForm>,
+        toFormValue(customer.address_2) as PathValue<TForm, Path<TForm>>,
+      );
+      setCustomerFieldValue(
+        "customer.post_code" as Path<TForm>,
+        toFormValue(customer.post_code) as PathValue<TForm, Path<TForm>>,
+      );
+      setCustomerFieldValue(
+        "customer.city" as Path<TForm>,
+        toFormValue(customer.city) as PathValue<TForm, Path<TForm>>,
+      );
+      setCustomerFieldValue(
+        "customer.state" as Path<TForm>,
+        toFormValue(customer.state) as PathValue<TForm, Path<TForm>>,
+      );
+      setCustomerFieldValue(
+        "customer.country" as Path<TForm>,
+        toFormValue(customer.country) as PathValue<TForm, Path<TForm>>,
+      );
+      setCustomerFieldValue(
+        "customer.tax_number" as Path<TForm>,
+        toFormValue(customer.tax_number) as PathValue<TForm, Path<TForm>>,
+      );
+      setCustomerFieldValue(
+        "customer.is_end_consumer" as Path<TForm>,
+        (customer.is_end_consumer ?? undefined) as PathValue<TForm, Path<TForm>>,
       );
       setOriginalCustomer(null);
       setSelectedCustomerId(undefined);
@@ -131,12 +156,36 @@ export function useDocumentCustomerForm<TForm extends DocumentFormWithCustomer>(
         is_end_consumer: customer.is_end_consumer ?? undefined,
       };
 
-      setValue("customer" as Path<TForm>, customerData as PathValue<TForm, Path<TForm>>);
+      setCustomerFieldValue("customer.name" as Path<TForm>, customerData.name as PathValue<TForm, Path<TForm>>);
+      setCustomerFieldValue("customer.address" as Path<TForm>, customerData.address as PathValue<TForm, Path<TForm>>);
+      setCustomerFieldValue(
+        "customer.address_2" as Path<TForm>,
+        customerData.address_2 as PathValue<TForm, Path<TForm>>,
+      );
+      setCustomerFieldValue(
+        "customer.post_code" as Path<TForm>,
+        customerData.post_code as PathValue<TForm, Path<TForm>>,
+      );
+      setCustomerFieldValue("customer.city" as Path<TForm>, customerData.city as PathValue<TForm, Path<TForm>>);
+      setCustomerFieldValue("customer.state" as Path<TForm>, customerData.state as PathValue<TForm, Path<TForm>>);
+      setCustomerFieldValue("customer.country" as Path<TForm>, customerData.country as PathValue<TForm, Path<TForm>>);
+      setCustomerFieldValue(
+        "customer.tax_number" as Path<TForm>,
+        customerData.tax_number as PathValue<TForm, Path<TForm>>,
+      );
+      setCustomerFieldValue(
+        "customer.is_end_consumer" as Path<TForm>,
+        customerData.is_end_consumer as PathValue<TForm, Path<TForm>>,
+      );
       setOriginalCustomer(customerData);
       setSelectedCustomerId(customerId);
       setShouldFocusName(false);
     }
 
+    form.clearErrors(["customer_id" as Path<TForm>, ...customerFieldPaths]);
+    if (form.formState.isSubmitted) {
+      void form.trigger();
+    }
     setShowCustomerForm(true);
   };
 

package/src/components/documents/documents.hooks.ts

@@ -1,5 +1,5 @@
+import { documents } from "@spaceinvoices/js-sdk";
 import { useMutation, useQueryClient } from "@tanstack/react-query";
-import { useSDK } from "@/ui/providers/sdk-provider";
 
 // Document type union for API calls
 export type DocumentType = "invoice" | "estimate" | "credit_note" | "advance_invoice" | "delivery_note";
@@ -35,7 +35,6 @@ type FinalizeDocumentVariables = {
  * Assigns a document number and runs fiscalization (if applicable)
  */
 export function useFinalizeDocument(options: FinalizeDocumentOptions) {
-  const { sdk } = useSDK();
   const queryClient = useQueryClient();
 
   return useMutation({
@@ -43,7 +42,7 @@ export function useFinalizeDocument(options: FinalizeDocumentOptions) {
       const body: Record<string, unknown> = {};
       if (furs) body.furs = furs;
       if (fina) body.fina = fina;
-      return sdk.documents.finalizeDocument(documentId, body, { type: documentType });
+      return documents.finalizeDocument(documentId, body, { type: documentType });
     },
     onSuccess: (data, variables) => {
       // Invalidate list cache
@@ -83,12 +82,11 @@ type DeleteDraftDocumentVariables = {
  * Only draft documents can be deleted
  */
 export function useDeleteDraftDocument(options: DeleteDraftDocumentOptions) {
-  const { sdk } = useSDK();
   const queryClient = useQueryClient();
 
   return useMutation({
     mutationFn: async ({ documentId, documentType }: DeleteDraftDocumentVariables) => {
-      return sdk.documents.delete(documentId, { type: documentType });
+      return documents.delete(documentId, { type: documentType });
     },
     onSuccess: (_, variables) => {
       // Invalidate list cache

package/src/components/documents/index.ts

@@ -15,6 +15,7 @@ export { prepareDocumentSubmission } from "./create/prepare-document-submission"
 export { useDocumentCustomerForm } from "./create/use-document-customer-form";
 // Preview components
 export { default as DocumentPreview } from "./document-preview";
+export { PublicDocumentSummary } from "./public";
 export { ScaledDocumentPreview } from "./shared/scaled-document-preview";
 export { useA4Scaling } from "./shared/use-a4-scaling";
 // Types

package/src/components/documents/public/index.ts

@@ -0,0 +1 @@
+export { PublicDocumentSummary } from "./public-document-summary";