@b3dotfun/sdk 0.0.44 → 0.0.45

package/src/notifications/react/hooks/useNotifications.ts

@@ -0,0 +1,153 @@
+import { useEffect, useRef, useState } from "react";
+import { notificationsAPI } from "../../services/api";
+import type { UserData } from "../../types";
+
+/**
+ * React hook for managing B3 notifications
+ * Automatically uses the authenticated user's ID from JWT
+ *
+ * @example
+ * ```tsx
+ * import { useNotifications } from '@b3dotfun/sdk/notifications/react';
+ *
+ * function NotificationSettings() {
+ *   const { user, loading, connectEmail, connectTelegram, isEmailConnected } = useNotifications();
+ *
+ *   if (loading) return <div>Loading...</div>;
+ *
+ *   return (
+ *     <div>
+ *       {!isEmailConnected && (
+ *         <button onClick={() => connectEmail('user@example.com')}>
+ *           Connect Email
+ *         </button>
+ *       )}
+ *       <button onClick={connectTelegram}>Connect Telegram</button>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+export function useNotifications() {
+  const [user, setUser] = useState<UserData | null>(null);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState<Error | null>(null);
+
+  // Refs to track polling timers for cleanup
+  const telegramPollIntervalRef = useRef<NodeJS.Timeout | null>(null);
+  const telegramPollTimeoutRef = useRef<NodeJS.Timeout | null>(null);
+
+  // Cleanup function for Telegram polling
+  const cleanupTelegramPolling = () => {
+    if (telegramPollIntervalRef.current) {
+      clearInterval(telegramPollIntervalRef.current);
+      telegramPollIntervalRef.current = null;
+    }
+    if (telegramPollTimeoutRef.current) {
+      clearTimeout(telegramPollTimeoutRef.current);
+      telegramPollTimeoutRef.current = null;
+    }
+  };
+
+  // Load user data on mount
+  useEffect(() => {
+    loadUser();
+  }, []);
+
+  // Cleanup polling on unmount
+  useEffect(() => {
+    return () => {
+      cleanupTelegramPolling();
+    };
+  }, []);
+
+  const loadUser = async () => {
+    try {
+      setLoading(true);
+      setError(null);
+      const userData = await notificationsAPI.getUser();
+      setUser(userData);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to load user"));
+      console.error("Failed to load user:", err);
+    } finally {
+      setLoading(false);
+    }
+  };
+
+  const connectEmail = async (email: string) => {
+    try {
+      await notificationsAPI.connectEmail(email);
+      await loadUser(); // Refresh user data
+    } catch (err) {
+      console.error("Failed to connect email:", err);
+      throw err;
+    }
+  };
+
+  const connectTelegram = async () => {
+    try {
+      // Clear any existing polling before starting new one
+      cleanupTelegramPolling();
+
+      const { deepLink } = await notificationsAPI.getTelegramLink();
+      window.open(deepLink, "_blank");
+
+      // Poll for connection status
+      telegramPollIntervalRef.current = setInterval(async () => {
+        try {
+          const { connected } = await notificationsAPI.checkTelegramStatus();
+          if (connected) {
+            cleanupTelegramPolling();
+            await loadUser(); // Refresh user data
+          }
+        } catch (err) {
+          console.error("Failed to check Telegram status:", err);
+        }
+      }, 2000);
+
+      // Stop polling after 2 minutes
+      telegramPollTimeoutRef.current = setTimeout(() => {
+        cleanupTelegramPolling();
+      }, 120000);
+    } catch (err) {
+      console.error("Failed to connect Telegram:", err);
+      throw err;
+    }
+  };
+
+  const updateChannel = async (channelId: string, updates: { enabled?: boolean }) => {
+    try {
+      await notificationsAPI.updateChannel(channelId, updates);
+      await loadUser(); // Refresh user data
+    } catch (err) {
+      console.error("Failed to update channel:", err);
+      throw err;
+    }
+  };
+
+  const deleteChannel = async (channelId: string) => {
+    try {
+      await notificationsAPI.deleteChannel(channelId);
+      await loadUser(); // Refresh user data
+    } catch (err) {
+      console.error("Failed to delete channel:", err);
+      throw err;
+    }
+  };
+
+  return {
+    user,
+    loading,
+    error,
+    refresh: loadUser,
+    connectEmail,
+    connectTelegram,
+    updateChannel,
+    deleteChannel,
+    // Convenience helpers
+    isEmailConnected: user?.channels?.find(c => c.channel_type === "email")?.enabled === 1,
+    isTelegramConnected: user?.channels?.find(c => c.channel_type === "telegram")?.enabled === 1,
+    isDiscordConnected: user?.channels?.find(c => c.channel_type === "discord")?.enabled === 1,
+  };
+}

package/src/notifications/react/index.ts

@@ -0,0 +1 @@
+export * from "./hooks";

package/src/notifications/services/api.ts

@@ -0,0 +1,211 @@
+import { getAuthToken } from "@b3dotfun/sdk/shared/utils/auth-token";
+import type {
+  NotificationHistory,
+  NotificationPreferences,
+  SendNotificationRequest,
+  TelegramLinkResponse,
+  TelegramStatusResponse,
+  UserData,
+} from "../types";
+
+const DEFAULT_API_URL = "https://notifications.b3.fun";
+
+let apiUrl: string = DEFAULT_API_URL;
+
+export function setApiUrl(url: string) {
+  apiUrl = url;
+}
+
+export function getApiUrl(): string {
+  return apiUrl;
+}
+
+function getHeaders(includeAuth = false): HeadersInit {
+  const headers: HeadersInit = {
+    "Content-Type": "application/json",
+  };
+
+  if (includeAuth) {
+    const token = getAuthToken();
+    if (token) {
+      headers["Authorization"] = `Bearer ${token}`;
+    }
+  }
+
+  return headers;
+}
+
+export const notificationsAPI = {
+  // ===== USER MANAGEMENT =====
+
+  /**
+   * Register the current user (userId extracted from JWT)
+   */
+  async registerUser() {
+    const res = await fetch(`${apiUrl}/users`, {
+      method: "POST",
+      headers: getHeaders(true),
+    });
+    return res.json();
+  },
+
+  /**
+   * Get current user's profile and preferences
+   */
+  async getUser(): Promise<UserData> {
+    const res = await fetch(`${apiUrl}/users/me`, {
+      headers: getHeaders(true),
+    });
+    return res.json();
+  },
+
+  /**
+   * Get current user's notification history
+   */
+  async getHistory(appId?: string, limit = 100): Promise<NotificationHistory[]> {
+    const params = new URLSearchParams();
+    if (appId) params.append("appId", appId);
+    params.append("limit", limit.toString());
+
+    const res = await fetch(`${apiUrl}/users/me/history?${params}`, {
+      headers: getHeaders(true),
+    });
+    return res.json();
+  },
+
+  // ===== CHANNELS =====
+
+  /**
+   * Add a notification channel for current user
+   */
+  async addChannel(channelType: string, channelIdentifier: string, metadata?: Record<string, any>) {
+    const res = await fetch(`${apiUrl}/users/me/channels`, {
+      method: "POST",
+      headers: getHeaders(true),
+      body: JSON.stringify({
+        channelType,
+        channelIdentifier,
+        enabled: true,
+        metadata,
+      }),
+    });
+    return res.json();
+  },
+
+  /**
+   * Connect email for current user
+   */
+  async connectEmail(email: string) {
+    return this.addChannel("email", email);
+  },
+
+  /**
+   * Update a notification channel
+   */
+  async updateChannel(
+    channelId: string,
+    updates: { enabled?: boolean; channelIdentifier?: string; metadata?: Record<string, any> },
+  ) {
+    const res = await fetch(`${apiUrl}/users/me/channels/${channelId}`, {
+      method: "PUT",
+      headers: getHeaders(true),
+      body: JSON.stringify(updates),
+    });
+    return res.json();
+  },
+
+  /**
+   * Delete a notification channel
+   */
+  async deleteChannel(channelId: string) {
+    const res = await fetch(`${apiUrl}/users/me/channels/${channelId}`, {
+      method: "DELETE",
+      headers: getHeaders(true),
+    });
+    return res.json();
+  },
+
+  // ===== TELEGRAM =====
+
+  /**
+   * Get Telegram deep link for current user
+   */
+  async getTelegramLink(): Promise<TelegramLinkResponse> {
+    const res = await fetch(`${apiUrl}/telegram/request-link`, {
+      method: "POST",
+      headers: getHeaders(true),
+    });
+    return res.json();
+  },
+
+  /**
+   * Check current user's Telegram connection status
+   */
+  async checkTelegramStatus(): Promise<TelegramStatusResponse> {
+    const res = await fetch(`${apiUrl}/telegram/status/me`, {
+      headers: getHeaders(true),
+    });
+    return res.json();
+  },
+
+  // ===== APP PREFERENCES =====
+
+  /**
+   * Save notification preferences for an app
+   */
+  async savePreferences(appId: string, settings: NotificationPreferences) {
+    const res = await fetch(`${apiUrl}/users/me/apps/${appId}/settings`, {
+      method: "POST",
+      headers: getHeaders(true),
+      body: JSON.stringify({ ...settings, enabled: true }),
+    });
+    return res.json();
+  },
+
+  /**
+   * Get notification settings for an app
+   */
+  async getAppSettings(appId: string) {
+    const res = await fetch(`${apiUrl}/users/me/apps/${appId}/settings`, {
+      headers: getHeaders(true),
+    });
+    return res.json();
+  },
+
+  // ===== IN-APP NOTIFICATIONS =====
+
+  /**
+   * Get current user's in-app notifications
+   */
+  async getInAppNotifications() {
+    const res = await fetch(`${apiUrl}/users/me/notifications`, {
+      headers: getHeaders(true),
+    });
+    return res.json();
+  },
+
+  /**
+   * Mark a notification as read
+   */
+  async markNotificationAsRead(notificationId: string) {
+    const res = await fetch(`${apiUrl}/users/me/notifications/${notificationId}/read`, {
+      method: "PUT",
+      headers: getHeaders(true),
+    });
+    return res.json();
+  },
+
+  // ===== SENDING NOTIFICATIONS =====
+
+  /**
+   * Send a notification (requires auth)
+   */
+  async sendNotification(data: SendNotificationRequest) {
+    const res = await fetch(`${apiUrl}/send`, {
+      method: "POST",
+      headers: getHeaders(true),
+      body: JSON.stringify(data),
+    });
+    return res.json();
+  },
+};

package/src/notifications/services/index.ts

@@ -0,0 +1 @@
+export * from "./api";

package/src/notifications/types/index.ts

@@ -0,0 +1,57 @@
+export type ChannelType = "email" | "telegram" | "discord" | "sms" | "whatsapp" | "in_app";
+
+export interface NotificationChannel {
+  id: number;
+  channel_type: ChannelType;
+  enabled: number;
+  channel_identifier: string;
+}
+
+export interface UserData {
+  user: {
+    id: number;
+    user_id: string;
+  };
+  channels: NotificationChannel[];
+  appSettings: Array<{
+    app_id: string;
+    notification_type: string;
+    enabled: number;
+    channels: string;
+  }>;
+}
+
+export interface NotificationHistory {
+  id: string;
+  app_id: string;
+  notification_type: string;
+  title: string;
+  message: string;
+  created_at: string;
+  read: boolean;
+}
+
+export interface TelegramLinkResponse {
+  deepLink: string;
+  verificationCode: string;
+  botUsername: string;
+}
+
+export interface TelegramStatusResponse {
+  connected: boolean;
+  chatId?: string;
+}
+
+export interface NotificationPreferences {
+  notificationType: string;
+  channels: string[];
+}
+
+export interface SendNotificationRequest {
+  userId: string;
+  appId: string;
+  notificationType: string;
+  message: string;
+  title?: string;
+  data?: Record<string, any>;
+}

package/src/shared/utils/auth-token.ts

@@ -0,0 +1,13 @@
+import Cookies from "js-cookie";
+
+const B3_AUTH_COOKIE_NAME = "b3-auth";
+
+/**
+ * Get the authentication token from the B3 auth cookie
+ * This token is managed by the B3 Global Account authentication system
+ *
+ * @returns The JWT token string or null if not found
+ */
+export function getAuthToken(): string | null {
+  return Cookies.get(B3_AUTH_COOKIE_NAME) || null;
+}

package/src/shared/utils/index.ts

@@ -1,4 +1,5 @@
 // Export utility functions
+export * from "./auth-token";
 export * from "./cn";
 export * from "./formatNumber";
 export * from "./formatUsername";

package/dist/cjs/shared/react/hooks/__tests__/useCurrencyConversion.test.js

@@ -1,245 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const vitest_1 = require("vitest");
-const react_1 = require("@testing-library/react");
-const useCurrencyConversion_1 = require("../useCurrencyConversion");
-// Mock the external dependencies
-// Store mock rates for different quote currencies
-const mockRates = {};
-// Mock store state
-const mockStoreState = {
-    selectedCurrency: "B3",
-    baseCurrency: "B3",
-    setSelectedCurrency: vitest_1.vi.fn(),
-    setBaseCurrency: vitest_1.vi.fn(),
-};
-vitest_1.vi.mock("@b3dotfun/sdk/global-account/react", () => ({
-    useExchangeRate: vitest_1.vi.fn((params) => {
-        const rate = mockRates[params?.quoteCurrency];
-        return { rate };
-    }),
-}));
-vitest_1.vi.mock("@b3dotfun/sdk/shared/utils/number", () => ({
-    formatDisplayNumber: vitest_1.vi.fn((value) => {
-        const num = Number(value);
-        if (isNaN(num))
-            return "0";
-        return num.toLocaleString("en-US", { maximumFractionDigits: 6 });
-    }),
-}));
-vitest_1.vi.mock("../../stores/currencyStore", () => ({
-    useCurrencyStore: vitest_1.vi.fn((selector) => {
-        if (selector) {
-            return selector(mockStoreState);
-        }
-        return mockStoreState;
-    }),
-    CURRENCY_SYMBOLS: {
-        B3: "B3",
-        USD: "$",
-        EUR: "€",
-        GBP: "£",
-        JPY: "¥",
-        CAD: "C$",
-        AUD: "A$",
-        ETH: "ETH",
-        SOL: "SOL",
-        KRW: "₩",
-    },
-}));
-(0, vitest_1.describe)("useCurrencyConversion", () => {
-    (0, vitest_1.beforeEach)(() => {
-        vitest_1.vi.clearAllMocks();
-        // Reset mock rates to default
-        Object.keys(mockRates).forEach(key => delete mockRates[key]);
-        mockRates.USD = 1.0;
-        // Reset store state
-        mockStoreState.selectedCurrency = "B3";
-        mockStoreState.baseCurrency = "B3";
-    });
-    (0, vitest_1.describe)("formatCurrencyValue", () => {
-        (0, vitest_1.it)("should format base currency (B3) without conversion", () => {
-            mockStoreState.selectedCurrency = "B3";
-            mockStoreState.baseCurrency = "B3";
-            const { result } = (0, react_1.renderHook)(() => (0, useCurrencyConversion_1.useCurrencyConversion)());
-            const formatted = result.current.formatCurrencyValue(100);
-            (0, vitest_1.expect)(formatted).toContain("B3");
-            (0, vitest_1.expect)(formatted).toContain("100");
-        });
-        (0, vitest_1.it)("should show base currency when exchange rate is unavailable", () => {
-            mockRates.USD = undefined;
-            mockStoreState.selectedCurrency = "USD";
-            mockStoreState.baseCurrency = "B3";
-            const { result } = (0, react_1.renderHook)(() => (0, useCurrencyConversion_1.useCurrencyConversion)());
-            const formatted = result.current.formatCurrencyValue(100);
-            (0, vitest_1.expect)(formatted).toContain("B3");
-            (0, vitest_1.expect)(formatted).not.toContain("$");
-        });
-        (0, vitest_1.it)("should format USD with prefix symbol", () => {
-            mockRates.USD = 2.0;
-            mockStoreState.selectedCurrency = "USD";
-            mockStoreState.baseCurrency = "B3";
-            const { result } = (0, react_1.renderHook)(() => (0, useCurrencyConversion_1.useCurrencyConversion)());
-            const formatted = result.current.formatCurrencyValue(100);
-            (0, vitest_1.expect)(formatted).toMatch(/^\$/);
-            (0, vitest_1.expect)(formatted).toContain("200");
-        });
-        (0, vitest_1.it)("should format EUR with prefix symbol", () => {
-            mockRates.EUR = 1.8;
-            mockRates.USD = 2.0;
-            mockStoreState.selectedCurrency = "EUR";
-            mockStoreState.baseCurrency = "B3";
-            const { result } = (0, react_1.renderHook)(() => (0, useCurrencyConversion_1.useCurrencyConversion)());
-            const formatted = result.current.formatCurrencyValue(100);
-            (0, vitest_1.expect)(formatted).toMatch(/^€/);
-        });
-        (0, vitest_1.it)("should format JPY without decimals", () => {
-            mockRates.JPY = 150;
-            mockRates.USD = 2.0;
-            mockStoreState.selectedCurrency = "JPY";
-            mockStoreState.baseCurrency = "B3";
-            const { result } = (0, react_1.renderHook)(() => (0, useCurrencyConversion_1.useCurrencyConversion)());
-            const formatted = result.current.formatCurrencyValue(100);
-            (0, vitest_1.expect)(formatted).toContain("¥");
-            (0, vitest_1.expect)(formatted).not.toContain(".");
-        });
-        (0, vitest_1.it)("should format KRW without decimals", () => {
-            mockRates.KRW = 1300;
-            mockRates.USD = 2.0;
-            mockStoreState.selectedCurrency = "KRW";
-            mockStoreState.baseCurrency = "B3";
-            const { result } = (0, react_1.renderHook)(() => (0, useCurrencyConversion_1.useCurrencyConversion)());
-            const formatted = result.current.formatCurrencyValue(100);
-            (0, vitest_1.expect)(formatted).toContain("₩");
-            (0, vitest_1.expect)(formatted).not.toContain(".");
-        });
-        (0, vitest_1.it)("should format ETH with suffix symbol", () => {
-            mockRates.ETH = 0.0005;
-            mockRates.USD = 2.0;
-            mockStoreState.selectedCurrency = "ETH";
-            mockStoreState.baseCurrency = "B3";
-            const { result } = (0, react_1.renderHook)(() => (0, useCurrencyConversion_1.useCurrencyConversion)());
-            const formatted = result.current.formatCurrencyValue(100);
-            (0, vitest_1.expect)(formatted).toContain("ETH");
-            (0, vitest_1.expect)(formatted).not.toMatch(/^ETH/);
-        });
-        (0, vitest_1.it)("should format SOL with suffix symbol", () => {
-            mockRates.SOL = 0.05;
-            mockRates.USD = 2.0;
-            mockStoreState.selectedCurrency = "SOL";
-            mockStoreState.baseCurrency = "B3";
-            const { result } = (0, react_1.renderHook)(() => (0, useCurrencyConversion_1.useCurrencyConversion)());
-            const formatted = result.current.formatCurrencyValue(100);
-            (0, vitest_1.expect)(formatted).toContain("SOL");
-            (0, vitest_1.expect)(formatted).not.toMatch(/^SOL/);
-        });
-        (0, vitest_1.it)("should handle small USD amounts with proper conversion", () => {
-            mockRates.USD = 1.5;
-            mockStoreState.selectedCurrency = "USD";
-            mockStoreState.baseCurrency = "B3";
-            const { result } = (0, react_1.renderHook)(() => (0, useCurrencyConversion_1.useCurrencyConversion)());
-            const formatted = result.current.formatCurrencyValue(10);
-            // 10 * 1.5 = 15
-            (0, vitest_1.expect)(formatted).toMatch(/^\$/);
-            (0, vitest_1.expect)(formatted).toContain("15");
-        });
-        (0, vitest_1.it)("should apply correct exchange rate conversion", () => {
-            const testRate = 3.5;
-            mockRates.USD = testRate;
-            mockStoreState.selectedCurrency = "USD";
-            mockStoreState.baseCurrency = "B3";
-            const { result } = (0, react_1.renderHook)(() => (0, useCurrencyConversion_1.useCurrencyConversion)());
-            const inputValue = 100;
-            const formatted = result.current.formatCurrencyValue(inputValue);
-            (0, vitest_1.expect)(formatted).toContain("350");
-        });
-    });
-    (0, vitest_1.describe)("return values", () => {
-        (0, vitest_1.it)("should return selected currency", () => {
-            mockStoreState.selectedCurrency = "USD";
-            mockStoreState.baseCurrency = "B3";
-            const { result } = (0, react_1.renderHook)(() => (0, useCurrencyConversion_1.useCurrencyConversion)());
-            (0, vitest_1.expect)(result.current.selectedCurrency).toBe("USD");
-        });
-        (0, vitest_1.it)("should return base currency", () => {
-            mockStoreState.selectedCurrency = "USD";
-            mockStoreState.baseCurrency = "B3";
-            const { result } = (0, react_1.renderHook)(() => (0, useCurrencyConversion_1.useCurrencyConversion)());
-            (0, vitest_1.expect)(result.current.baseCurrency).toBe("B3");
-        });
-        (0, vitest_1.it)("should return exchange rate", () => {
-            const testRate = 2.5;
-            mockRates.USD = testRate;
-            mockStoreState.selectedCurrency = "USD";
-            mockStoreState.baseCurrency = "B3";
-            const { result } = (0, react_1.renderHook)(() => (0, useCurrencyConversion_1.useCurrencyConversion)());
-            (0, vitest_1.expect)(result.current.exchangeRate).toBe(testRate);
-        });
-        (0, vitest_1.it)("should return correct currency symbols", () => {
-            mockStoreState.selectedCurrency = "EUR";
-            mockStoreState.baseCurrency = "B3";
-            const { result } = (0, react_1.renderHook)(() => (0, useCurrencyConversion_1.useCurrencyConversion)());
-            (0, vitest_1.expect)(result.current.selectedCurrencySymbol).toBe("€");
-            (0, vitest_1.expect)(result.current.baseCurrencySymbol).toBe("B3");
-        });
-    });
-    (0, vitest_1.describe)("formatTooltipValue", () => {
-        (0, vitest_1.it)("should show USD equivalent when displaying base currency", () => {
-            mockRates.USD = 1.5;
-            mockStoreState.selectedCurrency = "B3";
-            mockStoreState.baseCurrency = "B3";
-            const { result } = (0, react_1.renderHook)(() => (0, useCurrencyConversion_1.useCurrencyConversion)());
-            const tooltip = result.current.formatTooltipValue(100);
-            (0, vitest_1.expect)(tooltip).toContain("USD");
-            (0, vitest_1.expect)(tooltip).toContain("150");
-        });
-        (0, vitest_1.it)("should show base currency when displaying other currency", () => {
-            mockRates.EUR = 0.9;
-            mockRates.USD = 1.2;
-            mockStoreState.selectedCurrency = "EUR";
-            mockStoreState.baseCurrency = "B3";
-            const { result } = (0, react_1.renderHook)(() => (0, useCurrencyConversion_1.useCurrencyConversion)());
-            const tooltip = result.current.formatTooltipValue(100);
-            (0, vitest_1.expect)(tooltip).toContain("B3");
-            (0, vitest_1.expect)(tooltip).toContain("100");
-        });
-        (0, vitest_1.it)("should handle custom currency for base currency", () => {
-            mockRates.USD = 2.0;
-            mockRates.EUR = 1.8;
-            mockStoreState.selectedCurrency = "EUR";
-            mockStoreState.baseCurrency = "B3";
-            const { result } = (0, react_1.renderHook)(() => (0, useCurrencyConversion_1.useCurrencyConversion)());
-            const tooltip = result.current.formatTooltipValue(100, "B3");
-            (0, vitest_1.expect)(tooltip).toContain("USD");
-            (0, vitest_1.expect)(tooltip).toContain("200");
-        });
-        (0, vitest_1.it)("should handle custom currency for non-base currency", () => {
-            mockRates.USD = 2.0;
-            mockStoreState.selectedCurrency = "USD";
-            mockStoreState.baseCurrency = "B3";
-            const { result } = (0, react_1.renderHook)(() => (0, useCurrencyConversion_1.useCurrencyConversion)());
-            const tooltip = result.current.formatTooltipValue(50, "ETH");
-            (0, vitest_1.expect)(tooltip).toContain("ETH");
-            (0, vitest_1.expect)(tooltip).toContain("50");
-        });
-        (0, vitest_1.it)("should handle absolute values for negative amounts", () => {
-            mockRates.USD = 1.5;
-            mockStoreState.selectedCurrency = "B3";
-            mockStoreState.baseCurrency = "B3";
-            const { result } = (0, react_1.renderHook)(() => (0, useCurrencyConversion_1.useCurrencyConversion)());
-            const tooltip = result.current.formatTooltipValue(-100);
-            (0, vitest_1.expect)(tooltip).toContain("USD");
-            (0, vitest_1.expect)(tooltip).toContain("150");
-            (0, vitest_1.expect)(tooltip).not.toContain("-");
-        });
-        (0, vitest_1.it)("should handle exchange rate unavailable", () => {
-            mockRates.USD = undefined;
-            mockStoreState.selectedCurrency = "B3";
-            mockStoreState.baseCurrency = "B3";
-            const { result } = (0, react_1.renderHook)(() => (0, useCurrencyConversion_1.useCurrencyConversion)());
-            const tooltip = result.current.formatTooltipValue(100);
-            (0, vitest_1.expect)(tooltip).toContain("USD");
-            (0, vitest_1.expect)(tooltip).toContain("100");
-        });
-    });
-});

package/dist/esm/shared/react/hooks/__tests__/useCurrencyConversion.test.d.ts

@@ -1 +0,0 @@
-export {};