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

package/src/utils/compression/compress.test.ts

@@ -0,0 +1,123 @@
+/**
+ * Tests for compressJsonToB64 utility function
+ * Tests JSON compression to base64url-encoded string
+ */
+
+import { vi } from "vitest";
+
+// Mock the frame-connector module - must be before imports
+vi.mock("@frak-labs/frame-connector", () => ({
+    compressJson: vi.fn((data: unknown) => {
+        // Simple mock: convert JSON to Uint8Array
+        const jsonString = JSON.stringify(data);
+        return new TextEncoder().encode(jsonString);
+    }),
+}));
+
+import { describe, expect, it } from "../../../tests/vitest-fixtures";
+import { compressJsonToB64 } from "./compress";
+
+describe("compressJsonToB64", () => {
+    describe("success cases", () => {
+        it("should compress and encode simple object", () => {
+            const data = { key: "value" };
+            const result = compressJsonToB64(data);
+
+            // Result should be a base64url-encoded string
+            expect(result).toBeDefined();
+            expect(typeof result).toBe("string");
+            expect(result.length).toBeGreaterThan(0);
+            // Base64url should not contain +, /, or = characters
+            expect(result).not.toMatch(/[+/=]/);
+        });
+
+        it("should compress and encode array data", () => {
+            const data = [1, 2, 3, 4, 5];
+            const result = compressJsonToB64(data);
+
+            expect(result).toBeDefined();
+            expect(typeof result).toBe("string");
+            expect(result.length).toBeGreaterThan(0);
+            expect(result).not.toMatch(/[+/=]/);
+        });
+
+        it("should compress and encode nested object", () => {
+            const data = {
+                user: {
+                    name: "John",
+                    address: {
+                        city: "Paris",
+                        country: "France",
+                    },
+                },
+            };
+            const result = compressJsonToB64(data);
+
+            expect(result).toBeDefined();
+            expect(typeof result).toBe("string");
+            expect(result.length).toBeGreaterThan(0);
+        });
+
+        it("should compress and encode string data", () => {
+            const data = "Hello, World!";
+            const result = compressJsonToB64(data);
+
+            expect(result).toBeDefined();
+            expect(typeof result).toBe("string");
+            expect(result.length).toBeGreaterThan(0);
+        });
+
+        it("should compress and encode number data", () => {
+            const data = 12345;
+            const result = compressJsonToB64(data);
+
+            expect(result).toBeDefined();
+            expect(typeof result).toBe("string");
+            expect(result.length).toBeGreaterThan(0);
+        });
+
+        it("should compress and encode boolean data", () => {
+            const data = true;
+            const result = compressJsonToB64(data);
+
+            expect(result).toBeDefined();
+            expect(typeof result).toBe("string");
+            expect(result.length).toBeGreaterThan(0);
+        });
+
+        it("should compress and encode null", () => {
+            const data = null;
+            const result = compressJsonToB64(data);
+
+            expect(result).toBeDefined();
+            expect(typeof result).toBe("string");
+            expect(result.length).toBeGreaterThan(0);
+        });
+    });
+
+    describe("edge cases", () => {
+        it("should handle empty object", () => {
+            const data = {};
+            const result = compressJsonToB64(data);
+
+            expect(result).toBeDefined();
+            expect(typeof result).toBe("string");
+        });
+
+        it("should handle empty array", () => {
+            const data: unknown[] = [];
+            const result = compressJsonToB64(data);
+
+            expect(result).toBeDefined();
+            expect(typeof result).toBe("string");
+        });
+
+        it("should handle empty string", () => {
+            const data = "";
+            const result = compressJsonToB64(data);
+
+            expect(result).toBeDefined();
+            expect(typeof result).toBe("string");
+        });
+    });
+});

package/src/utils/compression/decompress.test.ts

@@ -0,0 +1,145 @@
+/**
+ * Tests for decompressJsonFromB64 utility function
+ * Tests decompression of base64url-encoded JSON strings
+ */
+
+import { vi } from "vitest";
+
+// Mock the frame-connector module - must be before imports
+vi.mock("@frak-labs/frame-connector", () => ({
+    compressJson: vi.fn((data: unknown) => {
+        // Simple mock: convert JSON to Uint8Array
+        const jsonString = JSON.stringify(data);
+        return new TextEncoder().encode(jsonString);
+    }),
+    decompressJson: vi.fn((data: Uint8Array) => {
+        // Simple mock: convert Uint8Array back to JSON
+        const jsonString = new TextDecoder().decode(data);
+        return JSON.parse(jsonString);
+    }),
+}));
+
+import { describe, expect, it } from "../../../tests/vitest-fixtures";
+import { compressJsonToB64 } from "./compress";
+import { decompressJsonFromB64 } from "./decompress";
+
+describe("decompressJsonFromB64", () => {
+    describe("success cases", () => {
+        it("should decompress simple object", () => {
+            const original = { key: "value" };
+            const compressed = compressJsonToB64(original);
+            const decompressed =
+                decompressJsonFromB64<typeof original>(compressed);
+
+            expect(decompressed).toEqual(original);
+        });
+
+        it("should decompress array data", () => {
+            const original = [1, 2, 3, 4, 5];
+            const compressed = compressJsonToB64(original);
+            const decompressed =
+                decompressJsonFromB64<typeof original>(compressed);
+
+            expect(decompressed).toEqual(original);
+        });
+
+        it("should decompress nested object", () => {
+            const original = {
+                user: {
+                    name: "John",
+                    address: {
+                        city: "Paris",
+                        country: "France",
+                    },
+                },
+            };
+            const compressed = compressJsonToB64(original);
+            const decompressed =
+                decompressJsonFromB64<typeof original>(compressed);
+
+            expect(decompressed).toEqual(original);
+        });
+
+        it("should decompress string data", () => {
+            const original = "Hello, World!";
+            const compressed = compressJsonToB64(original);
+            const decompressed = decompressJsonFromB64<string>(compressed);
+
+            expect(decompressed).toBe(original);
+        });
+
+        it("should decompress number data", () => {
+            const original = 12345;
+            const compressed = compressJsonToB64(original);
+            const decompressed = decompressJsonFromB64<number>(compressed);
+
+            expect(decompressed).toBe(original);
+        });
+
+        it("should decompress boolean data", () => {
+            const original = true;
+            const compressed = compressJsonToB64(original);
+            const decompressed = decompressJsonFromB64<boolean>(compressed);
+
+            expect(decompressed).toBe(original);
+        });
+
+        it("should decompress null", () => {
+            const original = null;
+            const compressed = compressJsonToB64(original);
+            const decompressed = decompressJsonFromB64<null>(compressed);
+
+            expect(decompressed).toBeNull();
+        });
+    });
+
+    describe("round-trip compression", () => {
+        it("should preserve data through compress-decompress cycle", () => {
+            const original = {
+                id: 123,
+                name: "Test User",
+                tags: ["tag1", "tag2", "tag3"],
+                metadata: {
+                    created: "2024-01-01",
+                    updated: "2024-01-02",
+                },
+            };
+
+            const compressed = compressJsonToB64(original);
+            const decompressed =
+                decompressJsonFromB64<typeof original>(compressed);
+
+            expect(decompressed).toEqual(original);
+        });
+
+        it("should handle empty object round-trip", () => {
+            const original = {};
+            const compressed = compressJsonToB64(original);
+            const decompressed =
+                decompressJsonFromB64<typeof original>(compressed);
+
+            expect(decompressed).toEqual(original);
+        });
+
+        it("should handle empty array round-trip", () => {
+            const original: unknown[] = [];
+            const compressed = compressJsonToB64(original);
+            const decompressed =
+                decompressJsonFromB64<typeof original>(compressed);
+
+            expect(decompressed).toEqual(original);
+        });
+    });
+
+    describe("edge cases", () => {
+        it("should handle empty object round-trip gracefully", () => {
+            // Empty objects should compress and decompress correctly
+            const original = {};
+            const compressed = compressJsonToB64(original);
+            const decompressed =
+                decompressJsonFromB64<typeof original>(compressed);
+
+            expect(decompressed).toEqual(original);
+        });
+    });
+});

package/src/utils/compression/index.ts

@@ -1,3 +1,3 @@
+export { base64urlDecode, base64urlEncode } from "./b64";
 export { compressJsonToB64 } from "./compress";
 export { decompressJsonFromB64 } from "./decompress";
-export { base64urlDecode, base64urlEncode } from "./b64";

package/src/utils/computeProductId.test.ts

@@ -0,0 +1,80 @@
+/**
+ * Tests for computeProductId utility function
+ * Tests product ID computation from domain names with normalization
+ */
+
+import { keccak256, toHex } from "viem";
+import { describe, expect, it } from "../../tests/vitest-fixtures";
+import { computeProductId } from "./computeProductId";
+
+describe("computeProductId", () => {
+    it("should compute product ID from current domain (window.location.host)", () => {
+        // In JSDOM test environment, window.location.host is "localhost:3000"
+        const productId = computeProductId();
+
+        // Should compute keccak256 hash of window.location.host
+        const expectedId = keccak256(toHex(window.location.host));
+        expect(productId).toBe(expectedId);
+    });
+
+    it("should compute product ID from custom domain", () => {
+        const customDomain = "custom-domain.com";
+        const productId = computeProductId({ domain: customDomain });
+
+        // Should compute keccak256 hash of custom domain
+        const expectedId = keccak256(toHex(customDomain));
+        expect(productId).toBe(expectedId);
+    });
+
+    it("should remove www. prefix from domain before hashing", () => {
+        const domainWithWww = "www.example.com";
+        const productId = computeProductId({ domain: domainWithWww });
+
+        // Should compute keccak256 hash of "example.com" (www. removed)
+        const expectedId = keccak256(toHex("example.com"));
+        expect(productId).toBe(expectedId);
+    });
+
+    it("should produce same product ID for domain with and without www", () => {
+        const withWww = computeProductId({ domain: "www.example.com" });
+        const withoutWww = computeProductId({ domain: "example.com" });
+
+        // Both should produce the same hash
+        expect(withWww).toBe(withoutWww);
+    });
+
+    it("should produce different product IDs for different domains", () => {
+        const domain1ProductId = computeProductId({ domain: "domain1.com" });
+        const domain2ProductId = computeProductId({ domain: "domain2.com" });
+
+        // Different domains should produce different hashes
+        expect(domain1ProductId).not.toBe(domain2ProductId);
+    });
+
+    it("should use window.location.host when domain is not provided", () => {
+        // When no domain is provided, it should default to window.location.host
+        const productId = computeProductId();
+
+        // Should produce same result as using window.location.host explicitly
+        const expectedId = keccak256(toHex(window.location.host));
+        expect(productId).toBe(expectedId);
+    });
+
+    it("should handle subdomains correctly", () => {
+        const subdomain = "blog.example.com";
+        const productId = computeProductId({ domain: subdomain });
+
+        // Should compute keccak256 hash of "blog.example.com" (subdomain preserved)
+        const expectedId = keccak256(toHex(subdomain));
+        expect(productId).toBe(expectedId);
+    });
+
+    it("should only remove www prefix, not other w-prefixed subdomains", () => {
+        const domain = "web.example.com";
+        const productId = computeProductId({ domain });
+
+        // Should NOT remove "web." prefix, only "www."
+        const expectedId = keccak256(toHex("web.example.com"));
+        expect(productId).toBe(expectedId);
+    });
+});

package/src/utils/constants.test.ts

@@ -0,0 +1,23 @@
+/**
+ * Tests for constants
+ * Tests backup key constant value
+ */
+
+import { describe, expect, it } from "../../tests/vitest-fixtures";
+import { BACKUP_KEY } from "./constants";
+
+describe("constants", () => {
+    describe("BACKUP_KEY", () => {
+        it("should have correct backup key value", () => {
+            expect(BACKUP_KEY).toBe("nexus-wallet-backup");
+        });
+
+        it("should be a string", () => {
+            expect(typeof BACKUP_KEY).toBe("string");
+        });
+
+        it("should not be empty", () => {
+            expect(BACKUP_KEY.length).toBeGreaterThan(0);
+        });
+    });
+});

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/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/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/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");
+    });
+});