@frak-labs/core-sdk 0.1.0-beta.afa252b0 → 0.1.0-beta.b0bd1f8a

package/src/utils/formatAmount.test.ts

@@ -0,0 +1,113 @@
+/**
+ * Tests for formatAmount utility function
+ * Tests currency formatting with proper locale support
+ */
+
+import { describe, expect, it } from "../../tests/vitest-fixtures";
+import { formatAmount } from "./formatAmount";
+
+describe("formatAmount", () => {
+    it("should format EUR with French locale by default", () => {
+        const formatted = formatAmount(1000, "eur");
+
+        // French locale formats EUR with space between number and symbol
+        // Expected format: "1 000 €" or "1 000,00 €" depending on locale
+        expect(formatted).toContain("€");
+        expect(formatted).toContain("1");
+    });
+
+    it("should format USD with US locale", () => {
+        const formatted = formatAmount(1000, "usd");
+
+        // US locale formats USD with $ prefix
+        expect(formatted).toContain("$");
+        expect(formatted).toContain("1");
+    });
+
+    it("should format GBP with British locale", () => {
+        const formatted = formatAmount(1000, "gbp");
+
+        // British locale formats GBP with £ symbol
+        expect(formatted).toContain("£");
+        expect(formatted).toContain("1");
+    });
+
+    it("should format integer amounts without decimal places", () => {
+        const formatted = formatAmount(1000, "eur");
+
+        // Integer amounts should not show .00
+        // French locale: "1 000 €" or "1 000,00 €"
+        expect(formatted).toBeDefined();
+        expect(formatted.length).toBeGreaterThan(0);
+    });
+
+    it("should format decimal amounts with up to 2 decimal places", () => {
+        const formatted = formatAmount(1234.56, "eur");
+
+        // Should include decimal separator and digits
+        expect(formatted).toBeDefined();
+        expect(formatted).toContain("1");
+    });
+
+    it("should handle zero amount", () => {
+        const formatted = formatAmount(0, "eur");
+
+        // Should format zero properly
+        expect(formatted).toContain("0");
+        expect(formatted).toContain("€");
+    });
+
+    it("should handle large amounts", () => {
+        const formatted = formatAmount(1000000, "eur");
+
+        // Should format large numbers with proper thousand separators
+        expect(formatted).toContain("€");
+        expect(formatted).toBeDefined();
+    });
+
+    it("should default to EUR when currency is not provided", () => {
+        const formatted = formatAmount(1000);
+
+        // Should default to EUR
+        expect(formatted).toContain("€");
+    });
+
+    it("should format negative amounts", () => {
+        const formatted = formatAmount(-500, "eur");
+
+        // Should handle negative amounts
+        expect(formatted).toContain("-");
+        expect(formatted).toContain("€");
+    });
+
+    it("should round amounts with more than 2 decimal places", () => {
+        const formatted = formatAmount(1234.5678, "eur");
+
+        // Should round to max 2 decimal places
+        expect(formatted).toBeDefined();
+        // The exact format depends on locale, but should be rounded
+    });
+
+    it("should format small decimal amounts", () => {
+        const formatted = formatAmount(0.99, "usd");
+
+        // Should handle small amounts properly
+        expect(formatted).toContain("$");
+        expect(formatted).toContain("0");
+    });
+
+    it("should use correct locale for each currency", () => {
+        const eurFormatted = formatAmount(1000, "eur");
+        const usdFormatted = formatAmount(1000, "usd");
+        const gbpFormatted = formatAmount(1000, "gbp");
+
+        // Each should use different currency symbols
+        expect(eurFormatted).toContain("€");
+        expect(usdFormatted).toContain("$");
+        expect(gbpFormatted).toContain("£");
+
+        // All should be different formats due to different locales
+        expect(eurFormatted).not.toBe(usdFormatted);
+        expect(usdFormatted).not.toBe(gbpFormatted);
+    });
+});

package/src/utils/formatAmount.ts

@@ -0,0 +1,18 @@
+import type { Currency } from "../types";
+import { getSupportedCurrency } from "./getSupportedCurrency";
+import { getSupportedLocale } from "./getSupportedLocale";
+
+export function formatAmount(amount: number, currency?: Currency) {
+    // Get the supported locale (e.g. "fr-FR")
+    const supportedLocale = getSupportedLocale(currency);
+
+    // Get the supported currency (e.g. "eur")
+    const supportedCurrency = getSupportedCurrency(currency);
+
+    return amount.toLocaleString(supportedLocale, {
+        style: "currency",
+        currency: supportedCurrency,
+        minimumFractionDigits: 0,
+        maximumFractionDigits: 2,
+    });
+}

package/src/utils/getCurrencyAmountKey.test.ts

@@ -0,0 +1,44 @@
+/**
+ * Tests for getCurrencyAmountKey utility function
+ * Tests currency amount key generation
+ */
+
+import { describe, expect, it } from "../../tests/vitest-fixtures";
+import type { Currency } from "../types";
+import { getCurrencyAmountKey } from "./getCurrencyAmountKey";
+
+describe("getCurrencyAmountKey", () => {
+    it("should return eurAmount for undefined input", () => {
+        const result = getCurrencyAmountKey(undefined);
+
+        expect(result).toBe("eurAmount");
+    });
+
+    it("should return eurAmount for EUR", () => {
+        const result = getCurrencyAmountKey("eur");
+
+        expect(result).toBe("eurAmount");
+    });
+
+    it("should return usdAmount for USD", () => {
+        const result = getCurrencyAmountKey("usd");
+
+        expect(result).toBe("usdAmount");
+    });
+
+    it("should return gbpAmount for GBP", () => {
+        const result = getCurrencyAmountKey("gbp");
+
+        expect(result).toBe("gbpAmount");
+    });
+
+    it("should generate correct key format for all currencies", () => {
+        const validCurrencies: Currency[] = ["eur", "usd", "gbp"];
+
+        for (const currency of validCurrencies) {
+            const result = getCurrencyAmountKey(currency);
+            // Should match pattern: {currency}Amount
+            expect(result).toBe(`${currency}Amount`);
+        }
+    });
+});

package/src/utils/getCurrencyAmountKey.ts

@@ -0,0 +1,15 @@
+import type { Currency, TokenAmountType } from "../types";
+
+/**
+ * Get the currency amount key for a given currency
+ * @param currency - The currency to use
+ * @returns The currency amount key
+ */
+export function getCurrencyAmountKey(
+    currency?: Currency
+): keyof TokenAmountType {
+    if (!currency) {
+        return "eurAmount";
+    }
+    return `${currency}Amount` as keyof TokenAmountType;
+}

package/src/utils/getSupportedCurrency.test.ts

@@ -0,0 +1,51 @@
+/**
+ * Tests for getSupportedCurrency utility function
+ * Tests currency validation and fallback behavior
+ */
+
+import { describe, expect, it } from "../../tests/vitest-fixtures";
+import type { Currency } from "../types";
+import { getSupportedCurrency } from "./getSupportedCurrency";
+
+describe("getSupportedCurrency", () => {
+    it("should return EUR for undefined input", () => {
+        const result = getSupportedCurrency(undefined);
+
+        expect(result).toBe("eur");
+    });
+
+    it("should return EUR when provided", () => {
+        const result = getSupportedCurrency("eur");
+
+        expect(result).toBe("eur");
+    });
+
+    it("should return USD when provided", () => {
+        const result = getSupportedCurrency("usd");
+
+        expect(result).toBe("usd");
+    });
+
+    it("should return GBP when provided", () => {
+        const result = getSupportedCurrency("gbp");
+
+        expect(result).toBe("gbp");
+    });
+
+    it("should fall back to EUR for invalid currency", () => {
+        // Force cast to test runtime behavior
+        const invalidCurrency = "invalid" as Currency;
+        const result = getSupportedCurrency(invalidCurrency);
+
+        expect(result).toBe("eur");
+    });
+
+    it("should handle all valid currencies", () => {
+        const validCurrencies: Currency[] = ["eur", "usd", "gbp"];
+
+        for (const currency of validCurrencies) {
+            const result = getSupportedCurrency(currency);
+            expect(result).toBe(currency);
+        }
+    });
+});

package/src/utils/getSupportedCurrency.ts

@@ -0,0 +1,14 @@
+import { locales } from "../constants/locales";
+import type { Currency } from "../types";
+
+/**
+ * Get the supported currency for a given currency
+ * @param currency - The currency to use
+ * @returns The supported currency
+ */
+export function getSupportedCurrency(currency?: Currency): Currency {
+    if (!currency) {
+        return "eur";
+    }
+    return currency in locales ? currency : "eur";
+}

package/src/utils/getSupportedLocale.test.ts

@@ -0,0 +1,64 @@
+/**
+ * Tests for getSupportedLocale utility function
+ * Tests locale resolution from currency
+ */
+
+import { describe, expect, it } from "../../tests/vitest-fixtures";
+import { locales } from "../constants/locales";
+import type { Currency } from "../types";
+import { getSupportedLocale } from "./getSupportedLocale";
+
+describe("getSupportedLocale", () => {
+    it("should return EUR locale for undefined input", () => {
+        const result = getSupportedLocale(undefined);
+
+        expect(result).toBe(locales.eur);
+        expect(result).toBe("fr-FR");
+    });
+
+    it("should return French locale for EUR", () => {
+        const result = getSupportedLocale("eur");
+
+        expect(result).toBe(locales.eur);
+        expect(result).toBe("fr-FR");
+    });
+
+    it("should return US locale for USD", () => {
+        const result = getSupportedLocale("usd");
+
+        expect(result).toBe(locales.usd);
+        expect(result).toBe("en-US");
+    });
+
+    it("should return GB locale for GBP", () => {
+        const result = getSupportedLocale("gbp");
+
+        expect(result).toBe(locales.gbp);
+        expect(result).toBe("en-GB");
+    });
+
+    it("should fall back to EUR locale for invalid currency", () => {
+        // Force cast to test runtime behavior
+        const invalidCurrency = "invalid" as Currency;
+        const result = getSupportedLocale(invalidCurrency);
+
+        expect(result).toBe(locales.eur);
+        expect(result).toBe("fr-FR");
+    });
+
+    it("should return valid locale format", () => {
+        const validCurrencies: Currency[] = ["eur", "usd", "gbp"];
+
+        for (const currency of validCurrencies) {
+            const result = getSupportedLocale(currency);
+            // Should match locale format like "en-US", "fr-FR", etc.
+            expect(result).toMatch(/^[a-z]{2}-[A-Z]{2}$/);
+        }
+    });
+
+    it("should map all supported currencies to their locales", () => {
+        expect(getSupportedLocale("eur")).toBe("fr-FR");
+        expect(getSupportedLocale("usd")).toBe("en-US");
+        expect(getSupportedLocale("gbp")).toBe("en-GB");
+    });
+});

package/src/utils/getSupportedLocale.ts

@@ -0,0 +1,16 @@
+import { type LocalesKey, locales } from "../constants/locales";
+import type { Currency } from "../types";
+
+/**
+ * Get the supported locale for a given currency
+ * @param currency - The currency to use
+ * @returns The supported locale
+ */
+export function getSupportedLocale(
+    currency?: Currency
+): (typeof locales)[LocalesKey] {
+    if (!currency) {
+        return locales.eur;
+    }
+    return locales[currency] ?? locales.eur;
+}