@spaceinvoices/react-ui 0.4.11 → 0.4.31

package/src/hooks/use-duplicate-document.ts

@@ -1,5 +1,6 @@
 import type {
   AdvanceInvoice,
+  CalculateDocumentPreview,
   CreateAdvanceInvoiceRequest,
   CreateCreditNoteRequest,
   CreateDeliveryNoteRequest,
@@ -11,9 +12,16 @@ import type {
   Invoice,
 } from "@spaceinvoices/js-sdk";
 import { useQuery } from "@tanstack/react-query";
-
+import { buildCustomCreateTemplateFromDocument } from "@/ui/components/documents/create/custom-create-template";
+import { toDocumentFormItem } from "@/ui/components/documents/create/document-form-item";
+import { totalsDifferByCents } from "@/ui/components/documents/create/preserved-expected-total";
 import { useEntities } from "@/ui/providers/entities-context";
-import { useSDK } from "@/ui/providers/sdk-provider";
+import { advanceInvoices } from "../../../js-sdk/src/sdk/advance-invoices";
+import { creditNotes } from "../../../js-sdk/src/sdk/credit-notes";
+import { deliveryNotes } from "../../../js-sdk/src/sdk/delivery-notes";
+import { documents } from "../../../js-sdk/src/sdk/documents";
+import { estimates } from "../../../js-sdk/src/sdk/estimates";
+import { invoices } from "../../../js-sdk/src/sdk/invoices";
 
 const DUPLICATE_TIMING_EVENT = "si:duplicate-timing";
 
@@ -31,13 +39,32 @@ type CreateRequest =
   | CreateAdvanceInvoiceRequest
   | CreateDeliveryNoteRequest;
 
+function shouldCheckForPreservedTotal(document: any): boolean {
+  return document?.creation_source === "custom" || Math.abs(document?.rounding_correction ?? 0) > 0;
+}
+
+function buildCalculatePayload(values: Partial<CreateRequest>): CalculateDocumentPreview | null {
+  if (!values.items?.length) {
+    return null;
+  }
+
+  return {
+    items: values.items,
+    customer_id: (values as any).customer_id,
+    customer: (values as any).customer,
+    currency_code: (values as any).currency_code,
+    date: (values as any).date,
+    calculation_mode: (values as any).calculation_mode,
+  };
+}
+
 /**
  * Get document type from ID prefix
  */
 export function getDocumentTypeFromId(id: string): DocumentType | null {
   if (id.startsWith("inv_")) return "invoice";
   if (id.startsWith("est_")) return "estimate";
-  if (id.startsWith("cn_")) return "credit_note";
+  if (id.startsWith("cre_") || id.startsWith("cn_")) return "credit_note";
   if (id.startsWith("adv_")) return "advance_invoice";
   if (id.startsWith("del_")) return "delivery_note";
   return null;
@@ -68,34 +95,7 @@ export function getAllowedDuplicateTargets(sourceType: DocumentType): DocumentTy
  * Copies relevant fields and resets computed/generated ones
  */
 function transformDocumentForDuplication(source: Document, targetType: DocumentType): Partial<CreateRequest> {
-  // Transform items - copy only the fields needed for creation
-  // Use type assertion for items since all document item types share the same shape
-  const sourceItems = source.items as Array<{
-    type?: string | null;
-    name: string;
-    description: string | null;
-    quantity: number;
-    price: number;
-    gross_price?: number | null;
-    taxes: Array<{ tax_id?: string }>;
-  }>;
-  const items = sourceItems?.map((item) => ({
-    type: item.type ?? undefined,
-    name: item.name,
-    description: item.description,
-    // Separator items skip financial fields
-    ...(item.type !== "separator"
-      ? {
-          quantity: item.quantity,
-          // Use gross_price if set, otherwise use price. The form uses is_gross_price as a UI toggle.
-          price: item.gross_price ?? item.price,
-          // Copy tax references (tax_id), not computed tax data
-          taxes: item.taxes?.map((tax) => ({ tax_id: tax.tax_id })),
-          // Derive is_gross_price from whether gross_price is set
-          gross_price: item.gross_price ?? undefined,
-        }
-      : {}),
-  }));
+  const items = source.items?.map((item) => toDocumentFormItem(item as any));
 
   // Build customer data - always copy if available (form needs this for display)
   const customerData = source.customer
@@ -126,9 +126,14 @@ function transformDocumentForDuplication(source: Document, targetType: DocumentT
     items: items as any,
     // Currency
     currency_code: source.currency_code,
+    calculation_mode: (source as any).calculation_mode ?? undefined,
     // Notes
     note: source.note,
     payment_terms: source.payment_terms,
+    reference: (source as any).reference,
+    signature: (source as any).signature,
+    tax_clause: (source as any).tax_clause,
+    footer: (source as any).footer,
     // Date - use today's date as ISO string
     date: new Date().toISOString(),
     // Number - leave empty for auto-generation
@@ -137,7 +142,6 @@ function transformDocumentForDuplication(source: Document, targetType: DocumentT
     // Skip linking if source is a draft (drafts have no number/fiscalization)
     ...(isConversion && !(source as any).is_draft ? { linked_documents: [source.id] } : {}),
   };
-
   // Copy service dates when source is an invoice (available on invoices and credit notes)
   if (sourceType === "invoice" || sourceType === "credit_note") {
     const sourceDoc = source as any;
@@ -149,6 +153,20 @@ function transformDocumentForDuplication(source: Document, targetType: DocumentT
     }
   }
 
+  if (sourceType === "estimate") {
+    const sourceDoc = source as Estimate & { title_type?: "estimate" | "proforma_invoice" | null };
+    if (sourceDoc.title_type) {
+      (baseData as CreateEstimateRequest).title_type = sourceDoc.title_type;
+    }
+  }
+
+  if (sourceType === "delivery_note") {
+    const sourceDoc = source as DeliveryNote & { hide_prices?: boolean | null };
+    if (sourceDoc.hide_prices !== undefined && sourceDoc.hide_prices !== null) {
+      (baseData as CreateDeliveryNoteRequest).hide_prices = sourceDoc.hide_prices;
+    }
+  }
+
   return baseData;
 }
 
@@ -199,7 +217,6 @@ export function useDuplicateDocument({
   targetType,
   enabled = true,
 }: UseDuplicateDocumentOptions): UseDuplicateDocumentResult {
-  const { sdk } = useSDK();
   const { activeEntity } = useEntities();
 
   const sourceType = sourceId ? getDocumentTypeFromId(sourceId) : null;
@@ -221,16 +238,16 @@ export function useDuplicateDocument({
       // Fetch source document based on its type
       let source: Document;
       if (sourceType === "invoice") {
-        source = await sdk.invoices.get(sourceId, undefined, { entity_id: activeEntity.id });
+        source = await invoices.get(sourceId, undefined, { entity_id: activeEntity.id });
       } else if (sourceType === "estimate") {
-        source = await sdk.estimates.get(sourceId, undefined, { entity_id: activeEntity.id });
+        source = await estimates.get(sourceId, undefined, { entity_id: activeEntity.id });
       } else if (sourceType === "advance_invoice") {
-        source = await sdk.advanceInvoices.get(sourceId, undefined, { entity_id: activeEntity.id });
+        source = await advanceInvoices.get(sourceId, undefined, { entity_id: activeEntity.id });
       } else if (sourceType === "delivery_note") {
-        source = await sdk.deliveryNotes.get(sourceId, undefined, { entity_id: activeEntity.id });
+        source = await deliveryNotes.get(sourceId, undefined, { entity_id: activeEntity.id });
       } else {
         // Credit note
-        source = await sdk.creditNotes.get(sourceId, undefined, { entity_id: activeEntity.id });
+        source = await creditNotes.get(sourceId, undefined, { entity_id: activeEntity.id });
       }
 
       if (!source) {
@@ -238,6 +255,22 @@ export function useDuplicateDocument({
       }
 
       const initialValues = transformDocumentForDuplication(source, targetType);
+      if ((source as any).creation_source === "custom") {
+        (initialValues as any)._custom_create_template = buildCustomCreateTemplateFromDocument(source);
+      }
+      if (shouldCheckForPreservedTotal(source)) {
+        const calculatePayload = buildCalculatePayload(initialValues);
+        if (calculatePayload) {
+          const calculated = await documents.calculateDocumentPreview(
+            calculatePayload,
+            { type: targetType },
+            { entity_id: activeEntity.id },
+          );
+          if (totalsDifferByCents(calculated.total_with_tax, (source as any).total_with_tax)) {
+            (initialValues as any)._preserved_expected_total_with_tax = (source as any).total_with_tax;
+          }
+        }
+      }
 
       // Build source document summaries for conversions (different source → target type)
       const isConversion = sourceType !== targetType;

package/src/hooks/use-eslog-validation.ts

@@ -7,7 +7,11 @@
 
 import { useEffect, useState } from "react";
 
-type EslogError = { field: string; message: string };
+type EslogError = {
+  field: string;
+  message: string;
+  params?: Record<string, number | string>;
+};
 
 type Entity = {
   country_code?: string;

package/src/hooks/use-next-document-number.ts

@@ -1,6 +1,5 @@
 import { useQuery } from "@tanstack/react-query";
-
-import { useSDK } from "@/ui/providers/sdk-provider";
+import { documents } from "../../../js-sdk/src/sdk/documents";
 
 export const NEXT_DOCUMENT_NUMBER_CACHE_KEY = "next-document-number";
 
@@ -13,6 +12,16 @@ export type NextDocumentNumberResponse = {
     business_premise_name: string;
     electronic_device_name: string;
   } | null;
+  fina?: {
+    business_premise_name: string;
+    electronic_device_name: string;
+  } | null;
+  pt?: {
+    series_id: string;
+    series_code: string;
+    validation_code: string;
+    manual?: boolean;
+  } | null;
 };
 
 /**
@@ -30,8 +39,6 @@ export function useNextDocumentNumber(
     enabled?: boolean;
   },
 ) {
-  const { sdk } = useSDK();
-
   return useQuery<NextDocumentNumberResponse>({
     queryKey: [
       NEXT_DOCUMENT_NUMBER_CACHE_KEY,
@@ -41,7 +48,7 @@ export function useNextDocumentNumber(
       options?.electronicDeviceName,
     ],
     queryFn: async () => {
-      const response = await sdk.documents.getNextNumber(
+      const response = await documents.getNextNumber(
         {
           type: type as "invoice",
           business_premise_name: options?.businessPremiseName,
@@ -51,7 +58,7 @@ export function useNextDocumentNumber(
       );
       return response;
     },
-    enabled: options?.enabled !== false && !!entityId && !!sdk?.documents,
+    enabled: options?.enabled !== false && !!entityId,
     staleTime: 0, // Always refetch when form opens
   });
 }

package/src/hooks/use-resolved-entity-id.ts

@@ -0,0 +1,14 @@
+import { useEntitiesOptional } from "@/ui/providers/entities-context";
+
+export function useResolvedEntityId(explicitEntityId?: string | null, consumerName = "Space Invoices component") {
+  const entitiesContext = useEntitiesOptional();
+  const resolvedEntityId = explicitEntityId ?? entitiesContext?.activeEntity?.id ?? null;
+
+  if (!resolvedEntityId) {
+    throw new Error(
+      `${consumerName} requires an entity ID. Pass entityId explicitly or render it inside an EntitiesProvider with an active entity.`,
+    );
+  }
+
+  return resolvedEntityId;
+}

package/src/hooks/use-resource-mutation.ts

@@ -1,16 +1,13 @@
-import type SDK from "@spaceinvoices/js-sdk";
 import type { SDKMethodOptions } from "@spaceinvoices/js-sdk";
 import type { UseMutationOptions } from "@tanstack/react-query";
 
 import { useMutation, useQueryClient } from "@tanstack/react-query";
 
-import { useSDK } from "@/ui/providers/sdk-provider";
-
 type ResourceMutationOptions<TData, TError, TVariables, TContext> = {
-  /** The resource name in the SDK (e.g., 'customers', 'invoices') */
-  resourceName: keyof SDK;
-  /** The method name to call on the resource (e.g., 'create', 'update', 'delete') */
-  methodName: string;
+  /** Concrete SDK module method */
+  mutationFn: (...args: any[]) => Promise<TData>;
+  /** How to map TVariables to the mutationFn signature */
+  operation: "create" | "update" | "idOnly";
   /** The cache key(s) to invalidate after successful mutation */
   cacheKey: string | string[];
   /** Entity ID for multi-tenant filtering */
@@ -34,14 +31,13 @@ type ResourceMutationOptions<TData, TError, TVariables, TContext> = {
  * Automatically handles cache invalidation and error handling
  */
 export function useResourceMutation<TData, TError = Error, TVariables = unknown, TContext = unknown>({
-  resourceName,
-  methodName,
+  mutationFn,
+  operation,
   cacheKey,
   entityId,
   accountId,
   mutationOptions,
 }: ResourceMutationOptions<TData, TError, TVariables, TContext>) {
-  const { sdk } = useSDK();
   const queryClient = useQueryClient();
 
   // Destructure to separate onSuccess/onError from other options
@@ -50,35 +46,20 @@ export function useResourceMutation<TData, TError = Error, TVariables = unknown,
   return useMutation<TData, TError, TVariables, TContext>({
     ...otherOptions,
     mutationFn: async (variables: TVariables) => {
-      // SDK is guaranteed non-null by provider - no need to check
-      const resource = sdk[resourceName] as Record<string, (...args: unknown[]) => Promise<unknown>>;
-
-      if (!resource || typeof resource[methodName] !== "function") {
-        throw new Error(`Method ${methodName} not found on resource ${String(resourceName)}`);
-      }
-
       // Build SDK options (entity_id, etc.)
       const options: SDKMethodOptions | undefined = entityId ? { entity_id: entityId } : undefined;
 
-      // SDK API: method(data, options) or method(id, data, options)
-      const isUpdateMethod = methodName === "update";
-      const isIdOnlyMethod =
-        methodName === "delete" || methodName.startsWith("restore") || methodName.startsWith("permanentDelete");
-
-      if (isUpdateMethod) {
-        // Update: method(id, data, options)
+      if (operation === "update") {
         const { id, data } = variables as { id: string; data: unknown };
-        return (await resource[methodName](id, data, options)) as TData;
+        return (await mutationFn(id, data, options)) as TData;
       }
 
-      if (isIdOnlyMethod) {
-        // Delete/Restore/PermanentDelete: method(id, options)
+      if (operation === "idOnly") {
         const { id } = variables as { id: string };
-        return (await resource[methodName](id, options)) as TData;
+        return (await mutationFn(id, options)) as TData;
       }
 
-      // Create: method(data, options)
-      return (await resource[methodName](variables, options)) as TData;
+      return (await mutationFn(variables, options)) as TData;
     },
 
     onSuccess: (data, variables, context) => {

package/src/hooks/use-transaction-type-check.ts

@@ -1,7 +1,7 @@
 import type { TransactionTypeCheckRequest, TransactionTypeCheckResponse } from "@spaceinvoices/js-sdk";
 import { useQuery } from "@tanstack/react-query";
 import { useMemo } from "react";
-import { useSDK } from "../providers/sdk-provider";
+import { transactionType } from "../../../js-sdk/src/sdk/transaction-type";
 import { useDebounce } from "./use-debounce";
 
 export const TRANSACTION_TYPE_CHECK_CACHE_KEY = "transaction-type-check";
@@ -77,8 +77,6 @@ export function useTransactionTypeCheck({
   customerIsEndConsumer,
   enabled = true,
 }: UseTransactionTypeCheckParams): UseTransactionTypeCheckResult {
-  const { sdk } = useSDK();
-
   // Build the request object
   const requestData = useMemo((): TransactionTypeCheckRequest | null => {
     // Need at least issuer info to make a check
@@ -120,12 +118,9 @@ export function useTransactionTypeCheck({
     queryKey,
     queryFn: async () => {
       if (!debouncedRequest) throw new Error("No request data");
-      // Use sdk.vies.checkVies which hits the same endpoint types
-      // (sdk.transactionType is not reliably available in Vite pre-bundled builds)
-      const checkFn = sdk.transactionType?.checkTransactionType ?? sdk.vies.checkVies;
-      return checkFn(debouncedRequest);
+      return transactionType.checkTransactionType(debouncedRequest);
     },
-    enabled: enabled && !!sdk && !!debouncedRequest,
+    enabled: enabled && !!debouncedRequest,
     staleTime: CHECK_STALE_TIME,
     refetchOnWindowFocus: false,
   });

package/src/lib/browser-cookies.ts

@@ -64,7 +64,7 @@ export function deleteCookie(name: string, path = "/") {
   });
 
   // Also delete domain cookie (e.g. .spaceinvoices.com) if on spaceinvoices.com
-  const hostname = typeof window !== "undefined" ? window.location.hostname : globalThis.location?.hostname ?? "";
+  const hostname = typeof window !== "undefined" ? window.location.hostname : (globalThis.location?.hostname ?? "");
   if (hostname === "spaceinvoices.com" || hostname.endsWith(".spaceinvoices.com")) {
     setCookie(name, "", {
       path,

package/src/lib/country-capabilities.ts

@@ -0,0 +1,114 @@
+import type { AdvanceInvoice, CreditNote, DeliveryNote, Estimate, Invoice } from "@spaceinvoices/js-sdk";
+
+import type { PdfTemplateId } from "@/ui/components/documents/create/live-preview";
+import type { Entity } from "@/ui/providers/entities-context";
+
+export const PORTUGAL_COUNTRY_CODE = "PT";
+export const PORTUGAL_PDF_LOCALE = "pt-PT";
+export const PORTUGAL_CANONICAL_PDF_TEMPLATE: PdfTemplateId = "classic";
+const ACTIVE_ACCOUNT_COOKIE = "l.account";
+const SUPPORT_ACCOUNT_ID = import.meta.env.VITE_SUPPORT_ACCOUNT_ID || "acc_000000000000000000000001";
+
+export type CountryAwareDocument = Invoice | Estimate | CreditNote | AdvanceInvoice | DeliveryNote;
+export type CountryAwareDocumentType = "invoice" | "estimate" | "credit_note" | "advance_invoice" | "delivery_note";
+
+type CountryEntity = Pick<Entity, "country_code" | "settings"> | null | undefined;
+
+export function isPortugalEntity(entity: CountryEntity): boolean {
+  return entity?.country_code === PORTUGAL_COUNTRY_CODE;
+}
+
+function getCookieValue(name: string) {
+  if (typeof document === "undefined") {
+    return null;
+  }
+
+  const cookiePrefix = `${name}=`;
+  const rawCookie = document.cookie
+    .split(";")
+    .map((cookie) => cookie.trim())
+    .find((cookie) => cookie.startsWith(cookiePrefix));
+
+  if (!rawCookie) {
+    return null;
+  }
+  return decodeURIComponent(rawCookie.slice(cookiePrefix.length));
+}
+
+export function hasPortugalUiAccess() {
+  if (typeof document === "undefined") {
+    return true;
+  }
+
+  const activeAccountId = getCookieValue(ACTIVE_ACCOUNT_COOKIE);
+  return !!SUPPORT_ACCOUNT_ID && activeAccountId === SUPPORT_ACCOUNT_ID;
+}
+
+export function resolveDocumentPdfTemplate(entity: CountryEntity): PdfTemplateId {
+  if (isPortugalEntity(entity) && hasPortugalUiAccess()) {
+    return PORTUGAL_CANONICAL_PDF_TEMPLATE;
+  }
+
+  const settings = (entity?.settings as Record<string, unknown> | undefined) ?? {};
+  return (settings.pdf_template as PdfTemplateId) || "modern";
+}
+
+export function getPortugalEditBlockedReason(entity: CountryEntity): string | undefined {
+  if (!isPortugalEntity(entity) || !hasPortugalUiAccess()) {
+    return undefined;
+  }
+
+  return "Issued Portugal documents cannot be edited. Void the document instead.";
+}
+
+export function getEntityCountryCapabilities(entity: CountryEntity) {
+  const isPortugal = isPortugalEntity(entity) && hasPortugalUiAccess();
+  const isSlovenia = entity?.country_code === "SI";
+
+  return {
+    isPortugal,
+    isSlovenia,
+    usesFixedPdfTemplate: isPortugal,
+    showPtSaftExport: isPortugal,
+    showSloveniaVodExport: isSlovenia,
+    showPtAtcudSettings: isPortugal,
+    allowTemplateSettings: !isPortugal,
+    allowEmailSettings: !isPortugal,
+    showTemplatesSettings: !isPortugal,
+    showEmailSettings: !isPortugal,
+    allowPdfTemplateSelection: !isPortugal,
+    allowPdfLanguageSelection: !isPortugal,
+    allowDocumentDrafts: !isPortugal,
+    allowSavedItemFullEdit: !isPortugal,
+    resolvedPdfTemplate: resolveDocumentPdfTemplate(entity),
+    forcePdfLocale: isPortugal ? PORTUGAL_PDF_LOCALE : undefined,
+  };
+}
+
+export function getDocumentCountryCapabilities(
+  entity: CountryEntity,
+  documentType: CountryAwareDocumentType,
+  document?: Partial<CountryAwareDocument> | null,
+) {
+  const entityCapabilities = getEntityCountryCapabilities(entity);
+  const isDraft = document?.is_draft === true;
+
+  return {
+    ...entityCapabilities,
+    allowEmailSend: !entityCapabilities.isPortugal,
+    allowSendEmail: !entityCapabilities.isPortugal,
+    allowEditIssuedDocument: !entityCapabilities.isPortugal || isDraft,
+    allowEditDocument: !entityCapabilities.isPortugal || isDraft,
+    allowPaymentAction:
+      (documentType === "invoice" || documentType === "advance_invoice" || documentType === "credit_note") &&
+      !(entityCapabilities.isPortugal && documentType === "credit_note"),
+    allowPaymentActions:
+      (documentType === "invoice" || documentType === "advance_invoice" || documentType === "credit_note") &&
+      !(entityCapabilities.isPortugal && documentType === "credit_note"),
+    forceDocumentPdfLocale: entityCapabilities.forcePdfLocale,
+    isDraft,
+  };
+}
+
+export const getCountryUiCapabilities = getEntityCountryCapabilities;
+export const getDocumentUiCapabilities = getDocumentCountryCapabilities;

package/src/lib/date-fns-locale.ts

@@ -1,24 +1,5 @@
 import type { Locale } from "date-fns";
-import {
-  bg,
-  cs,
-  de,
-  enUS,
-  es,
-  et,
-  fi,
-  fr,
-  hr,
-  is,
-  it,
-  nb,
-  nl,
-  pl,
-  pt,
-  sk,
-  sl,
-  sv,
-} from "date-fns/locale";
+import { bg, cs, de, enUS, es, et, fi, fr, hr, is, it, nb, nl, pl, pt, sk, sl, sv } from "date-fns/locale";
 import { getLocaleLanguage } from "./locale";
 
 const DATE_FNS_LOCALES: Record<string, Locale> = {

package/src/lib/date-only.ts

@@ -0,0 +1,58 @@
+const DATE_ONLY_PATTERN = /^\d{4}-\d{2}-\d{2}$/;
+const LEADING_DATE_ONLY_PATTERN = /^(\d{4}-\d{2}-\d{2})(?:$|T)/;
+
+export function toLocalDateOnlyString(date: Date): string {
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, "0");
+  const day = String(date.getDate()).padStart(2, "0");
+  return `${year}-${month}-${day}`;
+}
+
+export function normalizeDateOnlyInput(value: string | undefined): string | undefined {
+  if (!value) return undefined;
+  if (DATE_ONLY_PATTERN.test(value)) return value;
+
+  const utcMidnightMatch = value.match(/^(\d{4}-\d{2}-\d{2})T00:00:00(?:\.000)?Z$/);
+  if (utcMidnightMatch) {
+    return utcMidnightMatch[1];
+  }
+
+  const date = new Date(value);
+  if (Number.isNaN(date.getTime())) {
+    return value;
+  }
+
+  return toLocalDateOnlyString(date);
+}
+
+export function toUtcMidnightIsoString(value: string | undefined): string | undefined {
+  const dateOnly = normalizeDateOnlyInput(value);
+  return dateOnly ? `${dateOnly}T00:00:00.000Z` : undefined;
+}
+
+export function extractDateOnlyToken(value: string | undefined): string | undefined {
+  return value?.match(LEADING_DATE_ONLY_PATTERN)?.[1];
+}
+
+export function formatDateOnlyForDisplay(
+  value: Date | string | null | undefined,
+  locale: string,
+  options: Intl.DateTimeFormatOptions = {
+    year: "numeric",
+    month: "short",
+    day: "numeric",
+  },
+): string {
+  if (!value) return "-";
+
+  const normalized = typeof value === "string" ? normalizeDateOnlyInput(value) ?? extractDateOnlyToken(value) : undefined;
+  const dateOnly = normalized ?? (value instanceof Date ? toLocalDateOnlyString(value) : undefined);
+
+  if (!dateOnly) {
+    return typeof value === "string" ? value : "-";
+  }
+
+  return new Intl.DateTimeFormat(locale, { ...options, timeZone: "UTC" }).format(
+    new Date(`${dateOnly}T00:00:00.000Z`),
+  );
+}

package/src/lib/document-display.ts

@@ -0,0 +1,18 @@
+type TranslateFn = (key: string) => string;
+
+type DraftDocumentLike = {
+  number?: string | null;
+  is_draft?: boolean | null;
+};
+
+export function isBackendDraftNumber(number: string | null | undefined): boolean {
+  return typeof number === "string" && number.trim().toLowerCase().startsWith("draft-");
+}
+
+export function getDisplayDocumentNumber(document: DraftDocumentLike, t: TranslateFn, fallback = "-"): string {
+  if (document.is_draft || isBackendDraftNumber(document.number)) {
+    return t("Draft");
+  }
+
+  return document.number?.trim() || fallback;
+}

package/src/lib/eslog-export.ts

@@ -0,0 +1,32 @@
+type EslogDocumentLike = {
+  eslog?: {
+    validation_status?: string | null;
+  } | null;
+};
+
+export type EslogSelectionState = {
+  selectedCount: number;
+  eligibleCount: number;
+  hasEligibleDocuments: boolean;
+  hasIneligibleDocuments: boolean;
+  allEligible: boolean;
+  noneEligible: boolean;
+  partiallyEligible: boolean;
+};
+
+export function getEslogSelectionState(documents: EslogDocumentLike[]): EslogSelectionState {
+  const selectedCount = documents.length;
+  const eligibleCount = documents.filter((document) => document.eslog?.validation_status === "valid").length;
+  const hasEligibleDocuments = eligibleCount > 0;
+  const hasIneligibleDocuments = eligibleCount < selectedCount;
+
+  return {
+    selectedCount,
+    eligibleCount,
+    hasEligibleDocuments,
+    hasIneligibleDocuments,
+    allEligible: selectedCount > 0 && eligibleCount === selectedCount,
+    noneEligible: selectedCount > 0 && eligibleCount === 0,
+    partiallyEligible: eligibleCount > 0 && eligibleCount < selectedCount,
+  };
+}