@spaceinvoices/react-ui 0.4.8 → 0.4.11

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

@@ -15,6 +15,13 @@ import { useQuery } from "@tanstack/react-query";
 import { useEntities } from "@/ui/providers/entities-context";
 import { useSDK } from "@/ui/providers/sdk-provider";
 
+const DUPLICATE_TIMING_EVENT = "si:duplicate-timing";
+
+function emitDuplicateDebug(detail: Record<string, unknown>) {
+  if (!import.meta.env.DEV || typeof window === "undefined") return;
+  window.dispatchEvent(new CustomEvent(DUPLICATE_TIMING_EVENT, { detail }));
+}
+
 export type DocumentType = "invoice" | "estimate" | "credit_note" | "advance_invoice" | "delivery_note";
 type Document = Invoice | Estimate | CreditNote | AdvanceInvoice | DeliveryNote;
 type CreateRequest =
@@ -127,9 +134,21 @@ function transformDocumentForDuplication(source: Document, targetType: DocumentT
     // Number - leave empty for auto-generation
     // Do NOT copy: number, totals, taxes, payments, furs, eslog, vies, shareable_id
     // Link back to source document when converting (e.g., delivery note → invoice)
-    ...(isConversion ? { linked_documents: [source.id] } : {}),
+    // 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;
+    if (sourceDoc.date_service) {
+      (baseData as any).date_service = sourceDoc.date_service;
+    }
+    if (sourceDoc.date_service_to) {
+      (baseData as any).date_service_to = sourceDoc.date_service_to;
+    }
+  }
+
   return baseData;
 }
 
@@ -192,6 +211,13 @@ export function useDuplicateDocument({
         throw new Error("Source document ID and entity ID are required");
       }
 
+      const startedAt = performance.now();
+      emitDuplicateDebug({
+        stage: "request_started",
+        sourceId,
+        sourceType,
+        targetType,
+      });
       // Fetch source document based on its type
       let source: Document;
       if (sourceType === "invoice") {
@@ -215,22 +241,34 @@ export function useDuplicateDocument({
 
       // Build source document summaries for conversions (different source → target type)
       const isConversion = sourceType !== targetType;
-      const sourceDocuments: LinkedDocumentSummary[] = isConversion
-        ? [
-            {
-              id: source.id,
-              type: sourceType,
-              number: (source as any).number || "",
-              date: (source as any).date || "",
-              total_with_tax: (source as any).total_with_tax ?? 0,
-              currency_code: (source as any).currency_code || "",
-            },
-          ]
-        : [];
+      const sourceDocuments: LinkedDocumentSummary[] =
+        isConversion && !(source as any).is_draft
+          ? [
+              {
+                id: source.id,
+                type: sourceType,
+                number: (source as any).number || "",
+                date: (source as any).date || "",
+                total_with_tax: (source as any).total_with_tax ?? 0,
+                currency_code: (source as any).currency_code || "",
+              },
+            ]
+          : [];
+
+      emitDuplicateDebug({
+        stage: "request_succeeded",
+        sourceId,
+        sourceType,
+        targetType,
+        elapsedMs: Number((performance.now() - startedAt).toFixed(1)),
+      });
 
       return { initialValues, sourceDocuments };
     },
     enabled: enabled && !!sourceId && !!activeEntity?.id && !!sourceType,
+    retry: false,
+    refetchOnWindowFocus: false,
+    refetchOnReconnect: false,
   });
 
   return {

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

@@ -0,0 +1,59 @@
+/**
+ * Shared hook for eSLOG validation state.
+ *
+ * Encapsulates the eSLOG availability check, enabled toggle, and
+ * entity error tracking duplicated across invoice and advance invoice forms.
+ */
+
+import { useEffect, useState } from "react";
+
+type EslogError = { field: string; message: string };
+
+type Entity = {
+  country_code?: string;
+  settings?: Record<string, any>;
+} | null;
+
+export type EslogValidationResult = {
+  /** Whether eSLOG is available (SI entity + setting enabled) */
+  isAvailable: boolean;
+  /** Current enabled state (undefined until initialized) */
+  isEnabled: boolean | undefined;
+  /** Toggle eSLOG validation on/off */
+  setEnabled: (v: boolean) => void;
+  /** Entity-level errors that require settings updates */
+  entityErrors: EslogError[];
+  /** Update entity errors (e.g. from validation results) */
+  setEntityErrors: (errors: EslogError[]) => void;
+};
+
+export function useEslogValidation(activeEntity: Entity): EslogValidationResult {
+  const isSlovenianEntity = activeEntity?.country_code === "SI";
+  const entityEslogEnabled = !!(activeEntity?.settings as any)?.eslog_validation_enabled;
+  const isAvailable = isSlovenianEntity && entityEslogEnabled;
+
+  const [isEnabled, setEnabled] = useState<boolean | undefined>(undefined);
+  const [entityErrors, setEntityErrors] = useState<EslogError[]>([]);
+
+  // Auto-enable when available and not yet initialized
+  useEffect(() => {
+    if (isAvailable && isEnabled === undefined) {
+      setEnabled(true);
+    }
+  }, [isAvailable, isEnabled]);
+
+  // Clear entity errors when disabled
+  useEffect(() => {
+    if (!isEnabled) {
+      setEntityErrors([]);
+    }
+  }, [isEnabled]);
+
+  return {
+    isAvailable,
+    isEnabled,
+    setEnabled,
+    entityErrors,
+    setEntityErrors,
+  };
+}

package/src/hooks/use-premise-selection.ts

@@ -0,0 +1,186 @@
+/**
+ * Shared hook for FURS/FINA premise and device selection.
+ *
+ * Encapsulates the premise/device loading, localStorage persistence,
+ * auto-selection, and readiness logic duplicated across invoice,
+ * credit note, and advance invoice create forms.
+ */
+
+import { useEffect, useMemo, useState } from "react";
+
+import { useFinaPremises, useFinaSettings } from "../components/entities/fina-settings-form/fina-settings.hooks";
+import { useFursPremises, useFursSettings } from "../components/entities/furs-settings-form/furs-settings.hooks";
+import {
+  type FinaCombo,
+  type FursCombo,
+  getLastUsedFinaCombo,
+  getLastUsedFursCombo,
+  setLastUsedFinaCombo,
+  setLastUsedFursCombo,
+} from "../components/invoices/invoices.hooks";
+
+/** Minimal premise shape needed by the hook */
+type Premise = {
+  id: string;
+  business_premise_name: string;
+  is_active?: boolean;
+  Devices?: Array<{
+    electronic_device_name: string;
+    is_active?: boolean;
+  }>;
+};
+
+export type PremiseSelectionResult = {
+  /** Whether the fiscalization system is enabled in settings */
+  isEnabled: boolean;
+  /** Raw settings object (for form-specific logic like unified_numbering) */
+  settings: any;
+  /** Whether settings/premises are still loading */
+  isLoading: boolean;
+  /** Active (non-archived) premises */
+  activePremises: Premise[];
+  /** Whether there are any active premises */
+  hasPremises: boolean;
+  /** Active devices for the currently selected premise */
+  activeDevices: Array<{ electronic_device_name: string; is_active?: boolean }>;
+  /** Currently selected premise name */
+  selectedPremiseName: string | undefined;
+  /** Currently selected device name */
+  selectedDeviceName: string | undefined;
+  /** Update selected premise */
+  setSelectedPremiseName: (name: string | undefined) => void;
+  /** Update selected device */
+  setSelectedDeviceName: (name: string | undefined) => void;
+  /** True when disabled OR both premise+device are selected */
+  isSelectionReady: boolean;
+  /** True when enabled, has premises, and both are selected */
+  isActive: boolean;
+  /** Save current combo to localStorage (call on successful submission) */
+  saveCombo: () => void;
+};
+
+export function usePremiseSelection(opts: {
+  entityId: string;
+  type: "furs" | "fina";
+  enabled?: boolean;
+}): PremiseSelectionResult {
+  const { entityId, type } = opts;
+  const externalEnabled = opts.enabled !== false;
+
+  // --- FURS hooks (only called when type is furs) ---
+  const { data: fursSettings, isLoading: isFursSettingsLoading } = useFursSettings(entityId, {
+    enabled: type === "furs" && externalEnabled,
+  });
+  const { data: fursPremises, isLoading: isFursPremisesLoading } = useFursPremises(entityId, {
+    enabled: type === "furs" && externalEnabled && fursSettings?.enabled === true,
+  });
+
+  // --- FINA hooks (only called when type is fina) ---
+  const { data: finaSettings, isLoading: isFinaSettingsLoading } = useFinaSettings(entityId, {
+    enabled: type === "fina" && externalEnabled,
+  });
+  const { data: finaPremises, isLoading: isFinaPremisesLoading } = useFinaPremises(entityId, {
+    enabled: type === "fina" && externalEnabled && finaSettings?.enabled === true,
+  });
+
+  // Unified values
+  const settings = type === "furs" ? fursSettings : finaSettings;
+  const premises = type === "furs" ? fursPremises : finaPremises;
+  const isSettingsLoading = type === "furs" ? isFursSettingsLoading : isFinaSettingsLoading;
+  const isPremisesLoading = type === "furs" ? isFursPremisesLoading : isFinaPremisesLoading;
+
+  const isEnabled = settings?.enabled === true;
+  const isLoading = isSettingsLoading || (isEnabled && isPremisesLoading);
+
+  const activePremises = useMemo(() => (premises?.filter((p: any) => p.is_active) as Premise[]) || [], [premises]);
+  const hasPremises = activePremises.length > 0;
+
+  // Selection state
+  const [selectedPremiseName, setSelectedPremiseName] = useState<string | undefined>();
+  const [selectedDeviceName, setSelectedDeviceName] = useState<string | undefined>();
+
+  // Active devices for selected premise
+  const activeDevices = useMemo(() => {
+    if (!selectedPremiseName) return [];
+    const premise = activePremises.find((p) => p.business_premise_name === selectedPremiseName);
+    const devices = premise?.Devices?.filter((d) => d.is_active) || [];
+    // For FURS, exclude the legacy "OLD" device
+    return type === "furs" ? devices.filter((d) => d.electronic_device_name !== "OLD") : devices;
+  }, [activePremises, selectedPremiseName, type]);
+
+  // Initialize selection from localStorage or first active combo
+  useEffect(() => {
+    if (!isEnabled || !hasPremises || selectedPremiseName) return;
+
+    const lastUsed = type === "furs" ? getLastUsedFursCombo(entityId) : getLastUsedFinaCombo(entityId);
+
+    if (lastUsed) {
+      const premise = activePremises.find((p) => p.business_premise_name === lastUsed.business_premise_name);
+      const device = premise?.Devices?.find(
+        (d) => d.electronic_device_name === lastUsed.electronic_device_name && d.is_active,
+      );
+      if (premise && device) {
+        setSelectedPremiseName(lastUsed.business_premise_name);
+        setSelectedDeviceName(lastUsed.electronic_device_name);
+        return;
+      }
+    }
+
+    // Fall back to first active premise/device
+    const firstPremise = activePremises[0];
+    const firstDevice = firstPremise?.Devices?.find((d) => d.is_active);
+    if (firstPremise && firstDevice) {
+      setSelectedPremiseName(firstPremise.business_premise_name);
+      setSelectedDeviceName(firstDevice.electronic_device_name);
+    }
+  }, [isEnabled, hasPremises, activePremises, entityId, selectedPremiseName, type]);
+
+  // When premise changes, auto-select first active device if current is invalid
+  useEffect(() => {
+    if (!selectedPremiseName) return;
+    const premise = activePremises.find((p) => p.business_premise_name === selectedPremiseName);
+    const devicesForPremise =
+      type === "furs"
+        ? premise?.Devices?.filter((d) => d.is_active && d.electronic_device_name !== "OLD")
+        : premise?.Devices?.filter((d) => d.is_active);
+    const firstDevice = devicesForPremise?.[0];
+    if (firstDevice && selectedDeviceName !== firstDevice.electronic_device_name) {
+      const currentDeviceInPremise = devicesForPremise?.find((d) => d.electronic_device_name === selectedDeviceName);
+      if (!currentDeviceInPremise) {
+        setSelectedDeviceName(firstDevice.electronic_device_name);
+      }
+    }
+  }, [selectedPremiseName, activePremises, selectedDeviceName, type]);
+
+  const isSelectionReady = !isEnabled || !hasPremises || (!!selectedPremiseName && !!selectedDeviceName);
+  const isActive = !!(isEnabled && hasPremises && selectedPremiseName && selectedDeviceName);
+
+  const saveCombo = () => {
+    if (!isActive || !selectedPremiseName || !selectedDeviceName) return;
+    const combo: FursCombo | FinaCombo = {
+      business_premise_name: selectedPremiseName,
+      electronic_device_name: selectedDeviceName,
+    };
+    if (type === "furs") {
+      setLastUsedFursCombo(entityId, combo);
+    } else {
+      setLastUsedFinaCombo(entityId, combo);
+    }
+  };
+
+  return {
+    isEnabled,
+    settings,
+    isLoading: !!isLoading,
+    activePremises,
+    hasPremises,
+    activeDevices,
+    selectedPremiseName,
+    selectedDeviceName,
+    setSelectedPremiseName,
+    setSelectedDeviceName,
+    isSelectionReady,
+    isActive,
+    saveCombo,
+  };
+}

package/src/lib/browser-cookies.ts

@@ -16,7 +16,7 @@ type CookieOptions = {
  * Sets a cookie with the given name, value, and options
  */
 export function setCookie(name: string, value: string, options: CookieOptions = {}) {
-  if (typeof window === "undefined") {
+  if (typeof document === "undefined") {
     console.warn("setCookie called on server");
     return;
   }
@@ -41,7 +41,7 @@ export function setCookie(name: string, value: string, options: CookieOptions =
  * Gets a cookie value by name
  */
 export function getCookie(name: string): string | undefined {
-  if (typeof window === "undefined") {
+  if (typeof document === "undefined") {
     return undefined;
   }
 
@@ -52,7 +52,7 @@ export function getCookie(name: string): string | undefined {
  * Removes a cookie by name, clearing both host-only and domain-scoped versions
  */
 export function deleteCookie(name: string, path = "/") {
-  if (typeof window === "undefined") {
+  if (typeof document === "undefined") {
     console.warn("deleteCookie called on server");
     return;
   }
@@ -64,7 +64,7 @@ export function deleteCookie(name: string, path = "/") {
   });
 
   // Also delete domain cookie (e.g. .spaceinvoices.com) if on spaceinvoices.com
-  const hostname = window.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/date-fns-locale.ts

@@ -0,0 +1,48 @@
+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 { getLocaleLanguage } from "./locale";
+
+const DATE_FNS_LOCALES: Record<string, Locale> = {
+  bg,
+  cs,
+  de,
+  en: enUS,
+  es,
+  et,
+  fi,
+  fr,
+  hr,
+  is,
+  it,
+  nb,
+  nl,
+  pl,
+  pt,
+  sk,
+  sl,
+  sv,
+};
+
+export function getDateFnsLocale(locale?: string): Locale {
+  const language = getLocaleLanguage(locale);
+  return DATE_FNS_LOCALES[language ?? ""] ?? enUS;
+}

package/src/lib/fiscalization-options.ts

@@ -0,0 +1,81 @@
+/**
+ * Pure functions for building FURS/FINA/eSLOG submission options.
+ *
+ * Extracted from the submit callbacks of invoice, credit note,
+ * and advance invoice forms where this logic was duplicated.
+ */
+
+export type FursSubmitOptions = { skip: true } | { business_premise_name: string; electronic_device_name: string };
+
+export type FinaSubmitOptions = {
+  business_premise_name: string;
+  electronic_device_name: string;
+  payment_type: string;
+};
+
+export type EslogSubmitOptions = {
+  validation_enabled: boolean;
+};
+
+/**
+ * Build FURS fiscalization options for document submission.
+ *
+ * Returns undefined when FURS should not be included (drafts, disabled, edit mode).
+ */
+export function buildFursOptions(opts: {
+  isDraft: boolean;
+  isEnabled: boolean;
+  isEditMode?: boolean;
+  skipFiscalization?: boolean;
+  premiseName?: string;
+  deviceName?: string;
+}): FursSubmitOptions | undefined {
+  if (opts.isDraft || opts.isEditMode || !opts.isEnabled) return undefined;
+  if (opts.skipFiscalization) return { skip: true };
+  if (opts.premiseName && opts.deviceName) {
+    return {
+      business_premise_name: opts.premiseName,
+      electronic_device_name: opts.deviceName,
+    };
+  }
+  return undefined;
+}
+
+/**
+ * Build FINA fiscalization options for document submission.
+ *
+ * Returns undefined when FINA should not be included (drafts, numbering disabled).
+ */
+export function buildFinaOptions(opts: {
+  isDraft: boolean;
+  useFinaNumbering: boolean;
+  isEditMode?: boolean;
+  premiseName?: string;
+  deviceName?: string;
+  paymentType?: string;
+}): FinaSubmitOptions | undefined {
+  if (opts.isDraft || opts.isEditMode || !opts.useFinaNumbering) return undefined;
+  if (opts.premiseName && opts.deviceName) {
+    return {
+      business_premise_name: opts.premiseName,
+      electronic_device_name: opts.deviceName,
+      payment_type: opts.paymentType || "bank_transfer",
+    };
+  }
+  return undefined;
+}
+
+/**
+ * Build eSLOG validation options for document submission.
+ *
+ * Returns undefined when eSLOG should not be included (drafts, edit mode, unavailable).
+ */
+export function buildEslogOptions(opts: {
+  isDraft: boolean;
+  isEditMode?: boolean;
+  isAvailable: boolean;
+  isEnabled: boolean | undefined;
+}): EslogSubmitOptions | undefined {
+  if (opts.isDraft || opts.isEditMode || !opts.isAvailable) return undefined;
+  return { validation_enabled: opts.isEnabled === true };
+}

package/src/lib/locale.ts

@@ -0,0 +1,38 @@
+export function normalizeLocale(locale?: string, fallback = "en"): string {
+  return locale?.trim().toLowerCase().replace(/_/g, "-") || fallback;
+}
+
+export function getLocaleLanguage(locale?: string, fallback = "en"): string {
+  return normalizeLocale(locale, fallback).split("-")[0] || fallback;
+}
+
+const LANGUAGE_TO_LOCALE: Record<string, string> = {
+  en: "en-US",
+  de: "de-DE",
+  sl: "sl-SI",
+  it: "it-IT",
+  fr: "fr-FR",
+  es: "es-ES",
+  pt: "pt-PT",
+  nl: "nl-NL",
+  pl: "pl-PL",
+  hr: "hr-HR",
+  sv: "sv-SE",
+  fi: "fi-FI",
+  et: "et-EE",
+  bg: "bg-BG",
+  cs: "cs-CZ",
+  sk: "sk-SK",
+  nb: "nb-NO",
+  is: "is-IS",
+};
+
+export function getFullLocale(locale?: string, fallback = "en-US"): string {
+  const normalized = normalizeLocale(locale, fallback);
+  if (Object.values(LANGUAGE_TO_LOCALE).includes(normalized)) {
+    return normalized;
+  }
+
+  const language = getLocaleLanguage(normalized, fallback.split("-")[0]);
+  return LANGUAGE_TO_LOCALE[language] || fallback;
+}

package/src/lib/template-variables.tsx

@@ -26,7 +26,7 @@ export function getVariableValue(
 
   // Entity-related variables
   if (varName === "entity_name") return entity.name || null;
-  if (varName === "entity_email") return (entity.settings as any)?.email || null;
+  if (varName === "entity_email") return entity.email || null;
   if (varName === "entity_address") return entity.address || null;
   if (varName === "entity_post_code") return entity.post_code || null;
   if (varName === "entity_city") return entity.city || null;

package/src/lib/translation.ts

@@ -1,4 +1,5 @@
 import { useCallback } from "react";
+import { getLocaleLanguage, normalizeLocale } from "./locale";
 
 type TranslationFunction = (key: string) => string;
 
@@ -24,9 +25,19 @@ export function createTranslation({ t, namespace, locale = "en", translations =
         }
       }
 
-      // 2. Look up in local translations for current locale
-      if (translations[locale]) {
-        const translation = translations[locale][key];
+      const normalizedLocale = normalizeLocale(locale);
+      const baseLocale = getLocaleLanguage(normalizedLocale);
+
+      // 2. Look up in local translations for current locale, then base language
+      const localeTranslations = translations[normalizedLocale] ?? translations[baseLocale];
+      if (localeTranslations) {
+        const translation = localeTranslations[key];
+        if (translation) return translation;
+      }
+
+      const englishTranslations = translations.en;
+      if (englishTranslations) {
+        const translation = englishTranslations[key];
         if (translation) return translation;
       }
 

package/src/providers/entities-context.tsx

@@ -12,6 +12,7 @@ export type EntitiesContextType = {
   activeEntity: Entity | null;
   setActiveEntity: (entity: Entity | null) => void;
   environment: EntityEnvironment;
+  /** @deprecated Use URL-based sandbox routing instead of calling setEnvironment directly */
   setEnvironment: (environment: EntityEnvironment) => void;
   isLoading: boolean;
   refetchEntities: () => Promise<void>;