@spaceinvoices/react-ui 0.1.1

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

@@ -0,0 +1,118 @@
+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;
+  /** The cache key(s) to invalidate after successful mutation */
+  cacheKey: string | string[];
+  /** Entity ID for multi-tenant filtering */
+  entityId?: string | null;
+  /** Account ID for account-specific requests */
+  accountId?: string | null;
+  /** Additional mutation options from React Query */
+  mutationOptions?: Omit<
+    UseMutationOptions<TData, TError, TVariables, TContext>,
+    "mutationFn" | "onSuccess" | "onError"
+  > & {
+    /** Custom success callback - receives data, variables, and context */
+    onSuccess?: (data: TData, variables: TVariables, context: TContext | undefined) => void;
+    /** Custom error callback - receives error, variables, and context */
+    onError?: (error: TError, variables: TVariables, context: TContext | undefined) => void;
+  };
+};
+
+/**
+ * Generic hook for creating mutations for any resource in the SDK
+ * Automatically handles cache invalidation and error handling
+ */
+export function useResourceMutation<TData, TError = Error, TVariables = unknown, TContext = unknown>({
+  resourceName,
+  methodName,
+  cacheKey,
+  entityId,
+  accountId,
+  mutationOptions,
+}: ResourceMutationOptions<TData, TError, TVariables, TContext>) {
+  const { sdk } = useSDK();
+  const queryClient = useQueryClient();
+
+  // Destructure to separate onSuccess/onError from other options
+  const { onSuccess: customOnSuccess, onError: customOnError, ...otherOptions } = mutationOptions || {};
+
+  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 isDeleteMethod = methodName === "delete";
+
+      if (isUpdateMethod) {
+        // Update: method(id, data, options)
+        const { id, data } = variables as { id: string; data: unknown };
+        return (await resource[methodName](id, data, options)) as TData;
+      }
+
+      if (isDeleteMethod) {
+        // Delete: method(id, options)
+        const { id } = variables as { id: string };
+        return (await resource[methodName](id, options)) as TData;
+      }
+
+      // Create: method(data, options)
+      return (await resource[methodName](variables, options)) as TData;
+    },
+
+    onSuccess: (data, variables, context) => {
+      // Invalidate all relevant cache keys
+      invalidateCacheKeys(queryClient, cacheKey, entityId, accountId);
+
+      // Call custom onSuccess if provided
+      customOnSuccess?.(data, variables, context);
+    },
+
+    onError: (error, variables, context) => {
+      // Call custom onError if provided
+      customOnError?.(error, variables, context);
+    },
+  });
+}
+
+/**
+ * Invalidate cache keys - marks queries as stale and refetches active ones
+ */
+function invalidateCacheKeys(
+  queryClient: ReturnType<typeof useQueryClient>,
+  cacheKey: string | string[],
+  _entityId?: string | null,
+  _accountId?: string | null,
+): void {
+  const cacheKeys = Array.isArray(cacheKey) ? cacheKey : [cacheKey];
+
+  cacheKeys.forEach((key) => {
+    // Invalidate all queries that start with this cache key
+    // This marks them as stale (ignoring staleTime) and refetches active queries
+    queryClient.invalidateQueries({
+      queryKey: [key],
+      exact: false, // Match all queries starting with this key
+      refetchType: "active", // Refetch queries that are currently active
+    });
+  });
+}

package/src/hooks/use-vies-check.ts

@@ -0,0 +1,130 @@
+import type { ViesCheckRequest, ViesCheckResponse } from "@spaceinvoices/js-sdk";
+import { useQuery } from "@tanstack/react-query";
+import { useMemo } from "react";
+import { useSDK } from "../providers/sdk-provider";
+import { useDebounce } from "./use-debounce";
+
+export const VIES_CHECK_CACHE_KEY = "vies-check";
+
+/** Debounce delay for VIES checks (ms) */
+const VIES_DEBOUNCE_DELAY = 500;
+
+/** Cache time for VIES results - 5 minutes */
+const VIES_STALE_TIME = 5 * 60 * 1000;
+
+export interface UseViesCheckParams {
+  /** Issuer country name or code */
+  issuerCountry?: string | null;
+  /** Issuer country code (takes precedence over country name) */
+  issuerCountryCode?: string | null;
+  /** Whether the issuer is a tax subject (default: true) */
+  isTaxSubject?: boolean;
+  /** Customer country name or code */
+  customerCountry?: string | null;
+  /** Customer country code (takes precedence over country name) */
+  customerCountryCode?: string | null;
+  /** Customer VAT/tax number */
+  customerTaxNumber?: string | null;
+  /** Whether to enable the query (default: true) */
+  enabled?: boolean;
+}
+
+export interface UseViesCheckResult {
+  /** The VIES check result */
+  data: ViesCheckResponse | undefined;
+  /** Whether the query is loading */
+  isLoading: boolean;
+  /** Whether the query is fetching (includes background refetches) */
+  isFetching: boolean;
+  /** Error if the query failed */
+  error: Error | null;
+  /** Whether reverse charge should be applied */
+  reverseChargeApplies: boolean;
+  /** Transaction type determined by VIES check */
+  transactionType: ViesCheckResponse["transaction_type"] | undefined;
+  /** Warning message from VIES validation */
+  warning: string | null;
+  /** Whether VIES validation was successful */
+  viesValid: boolean | null;
+}
+
+/**
+ * Hook to check VIES status for a given issuer/customer combination.
+ * Uses debouncing to avoid excessive API calls during typing.
+ *
+ * @example
+ * ```tsx
+ * const { reverseChargeApplies, transactionType, warning } = useViesCheck({
+ *   issuerCountryCode: entity.country_code,
+ *   isTaxSubject: entity.is_tax_subject,
+ *   customerCountry: customer.country,
+ *   customerTaxNumber: customer.tax_number,
+ * });
+ *
+ * // Disable taxes when reverse charge applies
+ * if (reverseChargeApplies) {
+ *   // Show reverse charge message and disable tax controls
+ * }
+ * ```
+ */
+export function useViesCheck({
+  issuerCountry,
+  issuerCountryCode,
+  isTaxSubject = true,
+  customerCountry,
+  customerCountryCode,
+  customerTaxNumber,
+  enabled = true,
+}: UseViesCheckParams): UseViesCheckResult {
+  const { sdk } = useSDK();
+
+  // Build the request object
+  const requestData = useMemo((): ViesCheckRequest | null => {
+    // Need at least issuer info to make a check
+    if (!issuerCountry && !issuerCountryCode) return null;
+
+    // Need at least some customer info to make a meaningful check
+    if (!customerCountry && !customerCountryCode && !customerTaxNumber) return null;
+
+    return {
+      issuer: {
+        country: issuerCountry || undefined,
+        country_code: issuerCountryCode || undefined,
+        is_tax_subject: isTaxSubject,
+      },
+      customer: {
+        country: customerCountry || undefined,
+        country_code: customerCountryCode || undefined,
+        tax_number: customerTaxNumber || undefined,
+      },
+    };
+  }, [issuerCountry, issuerCountryCode, isTaxSubject, customerCountry, customerCountryCode, customerTaxNumber]);
+
+  // Debounce the request data to avoid excessive API calls
+  const debouncedRequest = useDebounce(requestData, VIES_DEBOUNCE_DELAY);
+
+  // Create a stable query key
+  const queryKey = useMemo(() => [VIES_CHECK_CACHE_KEY, debouncedRequest], [debouncedRequest]);
+
+  const query = useQuery({
+    queryKey,
+    queryFn: async () => {
+      if (!debouncedRequest) throw new Error("No request data");
+      return sdk.vies.checkVies(debouncedRequest);
+    },
+    enabled: enabled && !!sdk && !!debouncedRequest,
+    staleTime: VIES_STALE_TIME,
+    refetchOnWindowFocus: false,
+  });
+
+  return {
+    data: query.data,
+    isLoading: query.isLoading,
+    isFetching: query.isFetching,
+    error: query.error,
+    reverseChargeApplies: query.data?.reverse_charge_applies ?? false,
+    transactionType: query.data?.transaction_type,
+    warning: query.data?.warning ?? null,
+    viesValid: query.data?.vies_valid ?? null,
+  };
+}

package/src/index.css

@@ -0,0 +1,11 @@
+@import "../styles/globals.css";
+
+@layer base {
+  :root {
+    @apply font-sans;
+  }
+
+  body {
+    @apply grid place-items-center min-w-[320px] min-h-screen relative m-0 bg-background text-foreground;
+  }
+}

package/src/index.html

@@ -0,0 +1,13 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <!-- <link rel="icon" type="image/svg+xml" href="./logo.svg" /> -->
+    <title>Space Invoices React UI kit</title>
+    <script type="module" src="./frontend.tsx" async></script>
+  </head>
+  <body>
+    <div id="root"></div>
+  </body>
+</html>

package/src/index.tsx

@@ -0,0 +1,12 @@
+import { serve } from "bun";
+import index from "./index.html";
+
+// can set server to const
+serve({
+  routes: {
+    // Serve index.html for all unmatched routes.
+    "/*": index,
+  },
+
+  development: process.env.NODE_ENV !== "production",
+});

package/src/lib/auth.ts

@@ -0,0 +1,4 @@
+export const AUTH_COOKIES = {
+  TOKEN: "l.token",
+  USER: "l.user",
+} as const;

package/src/lib/browser-cookies.ts

@@ -0,0 +1,70 @@
+import { ACTIVE_ENTITY_COOKIE } from "@/ui/components/entities/keys";
+
+import { AUTH_COOKIES } from "./auth";
+import { getCookie as _getCookie } from "./cookies";
+
+type CookieOptions = {
+  path?: string;
+  expires?: Date;
+  maxAge?: number;
+  domain?: string;
+  secure?: boolean;
+  sameSite?: "Strict" | "Lax" | "None";
+};
+
+/**
+ * Sets a cookie with the given name, value, and options
+ */
+export function setCookie(name: string, value: string, options: CookieOptions = {}) {
+  if (typeof window === "undefined") {
+    console.warn("setCookie called on server");
+    return;
+  }
+
+  const { path = "/", expires, maxAge, domain, secure, sameSite = "Lax" } = options;
+
+  let cookie = `${encodeURIComponent(name)}=${encodeURIComponent(value)}`;
+
+  cookie += `; path=${path}`;
+
+  if (expires) cookie += `; expires=${expires.toUTCString()}`;
+  if (maxAge) cookie += `; max-age=${maxAge}`;
+  if (domain) cookie += `; domain=${domain}`;
+  if (secure) cookie += "; secure";
+  if (sameSite) cookie += `; samesite=${sameSite}`;
+
+  // biome-ignore lint/suspicious/noDocumentCookie: required for cookie helper
+  document.cookie = cookie;
+}
+
+/**
+ * Gets a cookie value by name
+ */
+export function getCookie(name: string): string | undefined {
+  if (typeof window === "undefined") {
+    return undefined;
+  }
+
+  return _getCookie(document.cookie, name);
+}
+
+/**
+ * Removes a cookie by name
+ */
+export function deleteCookie(name: string, path = "/") {
+  if (typeof window === "undefined") {
+    console.warn("deleteCookie called on server");
+    return;
+  }
+
+  setCookie(name, "", {
+    path,
+    expires: new Date(0),
+  });
+}
+
+export function flushCookies() {
+  deleteCookie(AUTH_COOKIES.TOKEN);
+  deleteCookie(AUTH_COOKIES.USER);
+  deleteCookie(ACTIVE_ENTITY_COOKIE);
+}

package/src/lib/constants.ts

@@ -0,0 +1,287 @@
+/**
+ * Shared constants for the UI library
+ */
+
+/**
+ * Supported currencies - comprehensive list of world currencies
+ * Includes: Major world currencies, G20 currencies, European currencies, and common trading currencies
+ * Sorted alphabetically by code (ISO 4217)
+ */
+export const CURRENCY_CODES = [
+  // Middle East
+  { value: "AED", label: "AED - UAE Dirham" },
+  // Africa
+  { value: "AFN", label: "AFN - Afghan Afghani" },
+  // Europe
+  { value: "ALL", label: "ALL - Albanian Lek" },
+  // Middle East
+  { value: "AMD", label: "AMD - Armenian Dram" },
+  // Caribbean
+  { value: "ANG", label: "ANG - Netherlands Antillean Guilder" },
+  // Africa
+  { value: "AOA", label: "AOA - Angolan Kwanza" },
+  // South America
+  { value: "ARS", label: "ARS - Argentine Peso" },
+  // Oceania
+  { value: "AUD", label: "AUD - Australian Dollar" },
+  // Caribbean
+  { value: "AWG", label: "AWG - Aruban Florin" },
+  // Europe
+  { value: "AZN", label: "AZN - Azerbaijani Manat" },
+  { value: "BAM", label: "BAM - Bosnia-Herzegovina Mark" },
+  // Caribbean
+  { value: "BBD", label: "BBD - Barbadian Dollar" },
+  // Asia
+  { value: "BDT", label: "BDT - Bangladeshi Taka" },
+  // Europe
+  { value: "BGN", label: "BGN - Bulgarian Lev" },
+  // Middle East
+  { value: "BHD", label: "BHD - Bahraini Dinar" },
+  // Africa
+  { value: "BIF", label: "BIF - Burundian Franc" },
+  // Caribbean
+  { value: "BMD", label: "BMD - Bermudian Dollar" },
+  // Asia
+  { value: "BND", label: "BND - Brunei Dollar" },
+  // South America
+  { value: "BOB", label: "BOB - Bolivian Boliviano" },
+  { value: "BRL", label: "BRL - Brazilian Real" },
+  // Caribbean
+  { value: "BSD", label: "BSD - Bahamian Dollar" },
+  // Asia
+  { value: "BTN", label: "BTN - Bhutanese Ngultrum" },
+  // Africa
+  { value: "BWP", label: "BWP - Botswanan Pula" },
+  // Europe
+  { value: "BYN", label: "BYN - Belarusian Ruble" },
+  // Central America
+  { value: "BZD", label: "BZD - Belize Dollar" },
+  // North America
+  { value: "CAD", label: "CAD - Canadian Dollar" },
+  // Africa
+  { value: "CDF", label: "CDF - Congolese Franc" },
+  // Europe
+  { value: "CHF", label: "CHF - Swiss Franc" },
+  // South America
+  { value: "CLP", label: "CLP - Chilean Peso" },
+  // Asia
+  { value: "CNY", label: "CNY - Chinese Yuan" },
+  // South America
+  { value: "COP", label: "COP - Colombian Peso" },
+  // Central America
+  { value: "CRC", label: "CRC - Costa Rican Colon" },
+  // Caribbean
+  { value: "CUP", label: "CUP - Cuban Peso" },
+  // Africa
+  { value: "CVE", label: "CVE - Cape Verdean Escudo" },
+  // Europe
+  { value: "CZK", label: "CZK - Czech Koruna" },
+  // Africa
+  { value: "DJF", label: "DJF - Djiboutian Franc" },
+  // Europe
+  { value: "DKK", label: "DKK - Danish Krone" },
+  // Caribbean
+  { value: "DOP", label: "DOP - Dominican Peso" },
+  // Africa
+  { value: "DZD", label: "DZD - Algerian Dinar" },
+  // Africa
+  { value: "EGP", label: "EGP - Egyptian Pound" },
+  // Africa
+  { value: "ERN", label: "ERN - Eritrean Nakfa" },
+  // Africa
+  { value: "ETB", label: "ETB - Ethiopian Birr" },
+  // Europe
+  { value: "EUR", label: "EUR - Euro" },
+  // Oceania
+  { value: "FJD", label: "FJD - Fijian Dollar" },
+  // Europe
+  { value: "GBP", label: "GBP - British Pound" },
+  { value: "GEL", label: "GEL - Georgian Lari" },
+  // Africa
+  { value: "GHS", label: "GHS - Ghanaian Cedi" },
+  // Europe
+  { value: "GIP", label: "GIP - Gibraltar Pound" },
+  // Africa
+  { value: "GMD", label: "GMD - Gambian Dalasi" },
+  { value: "GNF", label: "GNF - Guinean Franc" },
+  // Central America
+  { value: "GTQ", label: "GTQ - Guatemalan Quetzal" },
+  // South America
+  { value: "GYD", label: "GYD - Guyanese Dollar" },
+  // Asia
+  { value: "HKD", label: "HKD - Hong Kong Dollar" },
+  // Central America
+  { value: "HNL", label: "HNL - Honduran Lempira" },
+  // Europe
+  { value: "HRK", label: "HRK - Croatian Kuna" },
+  // Caribbean
+  { value: "HTG", label: "HTG - Haitian Gourde" },
+  // Europe
+  { value: "HUF", label: "HUF - Hungarian Forint" },
+  // Asia
+  { value: "IDR", label: "IDR - Indonesian Rupiah" },
+  { value: "ILS", label: "ILS - Israeli Shekel" },
+  { value: "INR", label: "INR - Indian Rupee" },
+  // Middle East
+  { value: "IQD", label: "IQD - Iraqi Dinar" },
+  { value: "IRR", label: "IRR - Iranian Rial" },
+  // Europe
+  { value: "ISK", label: "ISK - Icelandic Krona" },
+  // Caribbean
+  { value: "JMD", label: "JMD - Jamaican Dollar" },
+  // Middle East
+  { value: "JOD", label: "JOD - Jordanian Dinar" },
+  // Asia
+  { value: "JPY", label: "JPY - Japanese Yen" },
+  // Africa
+  { value: "KES", label: "KES - Kenyan Shilling" },
+  // Asia
+  { value: "KGS", label: "KGS - Kyrgystani Som" },
+  { value: "KHR", label: "KHR - Cambodian Riel" },
+  // Africa
+  { value: "KMF", label: "KMF - Comorian Franc" },
+  // Asia
+  { value: "KRW", label: "KRW - South Korean Won" },
+  // Middle East
+  { value: "KWD", label: "KWD - Kuwaiti Dinar" },
+  // Caribbean
+  { value: "KYD", label: "KYD - Cayman Islands Dollar" },
+  // Asia
+  { value: "KZT", label: "KZT - Kazakhstani Tenge" },
+  { value: "LAK", label: "LAK - Laotian Kip" },
+  // Middle East
+  { value: "LBP", label: "LBP - Lebanese Pound" },
+  // Asia
+  { value: "LKR", label: "LKR - Sri Lankan Rupee" },
+  // Africa
+  { value: "LRD", label: "LRD - Liberian Dollar" },
+  { value: "LSL", label: "LSL - Lesotho Loti" },
+  // Africa
+  { value: "LYD", label: "LYD - Libyan Dinar" },
+  { value: "MAD", label: "MAD - Moroccan Dirham" },
+  // Europe
+  { value: "MDL", label: "MDL - Moldovan Leu" },
+  // Africa
+  { value: "MGA", label: "MGA - Malagasy Ariary" },
+  // Europe
+  { value: "MKD", label: "MKD - Macedonian Denar" },
+  // Asia
+  { value: "MMK", label: "MMK - Myanmar Kyat" },
+  { value: "MNT", label: "MNT - Mongolian Tugrik" },
+  { value: "MOP", label: "MOP - Macanese Pataca" },
+  // Africa
+  { value: "MRU", label: "MRU - Mauritanian Ouguiya" },
+  { value: "MUR", label: "MUR - Mauritian Rupee" },
+  // Asia
+  { value: "MVR", label: "MVR - Maldivian Rufiyaa" },
+  // Africa
+  { value: "MWK", label: "MWK - Malawian Kwacha" },
+  // North America
+  { value: "MXN", label: "MXN - Mexican Peso" },
+  // Asia
+  { value: "MYR", label: "MYR - Malaysian Ringgit" },
+  // Africa
+  { value: "MZN", label: "MZN - Mozambican Metical" },
+  { value: "NAD", label: "NAD - Namibian Dollar" },
+  { value: "NGN", label: "NGN - Nigerian Naira" },
+  // Central America
+  { value: "NIO", label: "NIO - Nicaraguan Cordoba" },
+  // Europe
+  { value: "NOK", label: "NOK - Norwegian Krone" },
+  // Asia
+  { value: "NPR", label: "NPR - Nepalese Rupee" },
+  // Oceania
+  { value: "NZD", label: "NZD - New Zealand Dollar" },
+  // Middle East
+  { value: "OMR", label: "OMR - Omani Rial" },
+  // Central America
+  { value: "PAB", label: "PAB - Panamanian Balboa" },
+  // South America
+  { value: "PEN", label: "PEN - Peruvian Sol" },
+  // Oceania
+  { value: "PGK", label: "PGK - Papua New Guinean Kina" },
+  // Asia
+  { value: "PHP", label: "PHP - Philippine Peso" },
+  { value: "PKR", label: "PKR - Pakistani Rupee" },
+  // Europe
+  { value: "PLN", label: "PLN - Polish Zloty" },
+  // South America
+  { value: "PYG", label: "PYG - Paraguayan Guarani" },
+  // Middle East
+  { value: "QAR", label: "QAR - Qatari Rial" },
+  // Europe
+  { value: "RON", label: "RON - Romanian Leu" },
+  { value: "RSD", label: "RSD - Serbian Dinar" },
+  { value: "RUB", label: "RUB - Russian Ruble" },
+  // Africa
+  { value: "RWF", label: "RWF - Rwandan Franc" },
+  // Middle East
+  { value: "SAR", label: "SAR - Saudi Riyal" },
+  // Oceania
+  { value: "SBD", label: "SBD - Solomon Islands Dollar" },
+  // Africa
+  { value: "SCR", label: "SCR - Seychellois Rupee" },
+  { value: "SDG", label: "SDG - Sudanese Pound" },
+  // Europe
+  { value: "SEK", label: "SEK - Swedish Krona" },
+  // Asia
+  { value: "SGD", label: "SGD - Singapore Dollar" },
+  // Africa
+  { value: "SLL", label: "SLL - Sierra Leonean Leone" },
+  { value: "SOS", label: "SOS - Somali Shilling" },
+  // South America
+  { value: "SRD", label: "SRD - Surinamese Dollar" },
+  // Africa
+  { value: "SSP", label: "SSP - South Sudanese Pound" },
+  { value: "STN", label: "STN - Sao Tome and Principe Dobra" },
+  // Central America
+  { value: "SVC", label: "SVC - Salvadoran Colon" },
+  // Middle East
+  { value: "SYP", label: "SYP - Syrian Pound" },
+  // Africa
+  { value: "SZL", label: "SZL - Swazi Lilangeni" },
+  // Asia
+  { value: "THB", label: "THB - Thai Baht" },
+  { value: "TJS", label: "TJS - Tajikistani Somoni" },
+  { value: "TMT", label: "TMT - Turkmenistani Manat" },
+  // Africa
+  { value: "TND", label: "TND - Tunisian Dinar" },
+  // Oceania
+  { value: "TOP", label: "TOP - Tongan Pa'anga" },
+  // Europe
+  { value: "TRY", label: "TRY - Turkish Lira" },
+  // Caribbean
+  { value: "TTD", label: "TTD - Trinidad and Tobago Dollar" },
+  // Asia
+  { value: "TWD", label: "TWD - New Taiwan Dollar" },
+  // Africa
+  { value: "TZS", label: "TZS - Tanzanian Shilling" },
+  // Europe
+  { value: "UAH", label: "UAH - Ukrainian Hryvnia" },
+  // Africa
+  { value: "UGX", label: "UGX - Ugandan Shilling" },
+  // North America
+  { value: "USD", label: "USD - US Dollar" },
+  // South America
+  { value: "UYU", label: "UYU - Uruguayan Peso" },
+  // Asia
+  { value: "UZS", label: "UZS - Uzbekistan Som" },
+  // South America
+  { value: "VES", label: "VES - Venezuelan Bolivar" },
+  // Asia
+  { value: "VND", label: "VND - Vietnamese Dong" },
+  // Oceania
+  { value: "VUV", label: "VUV - Vanuatu Vatu" },
+  { value: "WST", label: "WST - Samoan Tala" },
+  // Africa
+  { value: "XAF", label: "XAF - Central African CFA Franc" },
+  { value: "XOF", label: "XOF - West African CFA Franc" },
+  // Middle East
+  { value: "YER", label: "YER - Yemeni Rial" },
+  // Africa
+  { value: "ZAR", label: "ZAR - South African Rand" },
+  { value: "ZMW", label: "ZMW - Zambian Kwacha" },
+  { value: "ZWL", label: "ZWL - Zimbabwean Dollar" },
+] as const;
+
+export type CurrencyCode = (typeof CURRENCY_CODES)[number]["value"];

package/src/lib/cookies.ts

@@ -0,0 +1,36 @@
+/**
+ * Cookie helper functions that work on both client and server
+ * provided a cookie string from the server or client headers
+ */
+
+export function getCookie(cookiesString: string, name: string) {
+  const value = `; ${cookiesString}`;
+  const parts = value.split(`; ${name}=`);
+  if (parts.length === 2) {
+    return decodeURIComponent(parts.pop()?.split(";").shift() ?? "");
+  }
+  return undefined;
+}
+
+export function removeCookie(cookiesString: string, cookieName: string): string {
+  if (!cookiesString) return "";
+
+  // Split cookies string into individual cookies
+  const cookies = cookiesString
+    .split(";")
+    .map((cookie) => cookie.trim())
+    .filter((cookie) => !cookie.startsWith(`${cookieName}=`));
+
+  // Join remaining cookies back together
+  return cookies.join("; ");
+}
+
+export function serializeCookie(
+  cookiesString: string,
+  name: string,
+  value: string,
+  options: { path?: string; maxAge?: number } = {},
+) {
+  const cookie = `${name}=${value}; path=${options.path || "/"}; max-age=${options.maxAge || 31536000}`;
+  return `${cookiesString}; ${cookie}`;
+}