@bettoredge/calcutta 0.2.0

package/src/hooks/useCalcuttaEscrow.ts

@@ -0,0 +1,52 @@
+import { useState, useCallback } from 'react';
+import { depositToEscrow, withdrawFromEscrow, getEscrowBalance } from '@bettoredge/api';
+import type { CalcuttaEscrowProps } from '@bettoredge/types';
+
+export interface CalcuttaEscrowState {
+    loading: boolean;
+    error?: string;
+    escrow?: CalcuttaEscrowProps;
+}
+
+export const useCalcuttaEscrow = (calcutta_competition_id?: string) => {
+    const [state, setState] = useState<CalcuttaEscrowState>({ loading: false });
+
+    const fetchEscrow = useCallback(async () => {
+        if (!calcutta_competition_id) return;
+        setState(prev => ({ ...prev, loading: true }));
+        try {
+            const resp = await getEscrowBalance(calcutta_competition_id);
+            setState({ loading: false, escrow: resp.escrow });
+        } catch {
+            setState(prev => ({ ...prev, loading: false }));
+        }
+    }, [calcutta_competition_id]);
+
+    const deposit = useCallback(async (amount: number) => {
+        if (!calcutta_competition_id) return;
+        setState(prev => ({ ...prev, loading: true, error: undefined }));
+        try {
+            const resp = await depositToEscrow(calcutta_competition_id, amount);
+            setState({ loading: false, escrow: resp.escrow });
+            return resp.escrow;
+        } catch (e: any) {
+            setState(prev => ({ ...prev, loading: false, error: e.message }));
+            throw e;
+        }
+    }, [calcutta_competition_id]);
+
+    const withdraw = useCallback(async (amount: number) => {
+        if (!calcutta_competition_id) return;
+        setState(prev => ({ ...prev, loading: true, error: undefined }));
+        try {
+            const resp = await withdrawFromEscrow(calcutta_competition_id, amount);
+            setState({ loading: false, escrow: resp.escrow });
+            return resp.escrow;
+        } catch (e: any) {
+            setState(prev => ({ ...prev, loading: false, error: e.message }));
+            throw e;
+        }
+    }, [calcutta_competition_id]);
+
+    return { ...state, fetchEscrow, deposit, withdraw };
+};

package/src/hooks/useCalcuttaItemImages.ts

@@ -0,0 +1,79 @@
+import { useState, useEffect, useCallback, useRef } from 'react';
+import { getBulkTeams, getBulkAthletes } from '@bettoredge/api';
+import type { CalcuttaAuctionItemProps } from '@bettoredge/types';
+
+export interface ItemImageMap {
+    [item_id: string]: { url: string } | undefined;
+}
+
+/**
+ * Fetches team/athlete images for calcutta auction items.
+ * Groups items by type (team vs athlete), bulk-fetches from sr_svc,
+ * and returns a map of item_id → image.
+ */
+export const useCalcuttaItemImages = (items: CalcuttaAuctionItemProps[]) => {
+    const [images, setImages] = useState<ItemImageMap>({});
+    const [loading, setLoading] = useState(false);
+    const fetchedRef = useRef<Set<string>>(new Set());
+
+    const fetchImages = useCallback(async (auctionItems: CalcuttaAuctionItemProps[]) => {
+        // Separate by type and dedupe against already-fetched
+        const teamIds: string[] = [];
+        const athleteIds: string[] = [];
+
+        for (const item of auctionItems) {
+            if (!item.item_id || fetchedRef.current.has(item.item_id)) continue;
+            if (item.item_type === 'team') {
+                teamIds.push(item.item_id);
+            } else if (item.item_type === 'athlete') {
+                athleteIds.push(item.item_id);
+            }
+        }
+
+        if (teamIds.length === 0 && athleteIds.length === 0) return;
+
+        setLoading(true);
+        const newImages: ItemImageMap = {};
+
+        try {
+            const [teamsRes, athletesRes] = await Promise.all([
+                teamIds.length > 0
+                    ? getBulkTeams({ attribute: 'team_id', values: teamIds }).catch(() => ({ teams: [] }))
+                    : { teams: [] },
+                athleteIds.length > 0
+                    ? getBulkAthletes({ attribute: 'athlete_id', values: athleteIds }).catch(() => ({ athletes: [] }))
+                    : { athletes: [] },
+            ]);
+
+            for (const team of (teamsRes.teams || [])) {
+                if (team.image?.url) {
+                    newImages[team.team_id] = team.image;
+                }
+                fetchedRef.current.add(team.team_id);
+            }
+
+            for (const athlete of (athletesRes.athletes || [])) {
+                if (athlete.image?.url) {
+                    newImages[athlete.athlete_id] = athlete.image;
+                }
+                fetchedRef.current.add(athlete.athlete_id);
+            }
+
+            if (Object.keys(newImages).length > 0) {
+                setImages(prev => ({ ...prev, ...newImages }));
+            }
+        } catch {
+            // Silently fail — items will show fallback icons
+        }
+
+        setLoading(false);
+    }, []);
+
+    useEffect(() => {
+        if (items.length > 0) {
+            fetchImages(items);
+        }
+    }, [items.map(i => i.item_id).join(','), fetchImages]);
+
+    return { images, loading };
+};

package/src/hooks/useCalcuttaPlayers.ts

@@ -0,0 +1,46 @@
+import { useState, useEffect, useRef, useCallback } from 'react';
+import { getPlayersByIds } from '@bettoredge/api';
+import type { PublicPlayerProps } from '@bettoredge/types';
+
+export interface CalcuttaPlayersState {
+    players: Record<string, PublicPlayerProps>;
+    loading: boolean;
+}
+
+export const useCalcuttaPlayers = (player_ids: string[]) => {
+    const [state, setState] = useState<CalcuttaPlayersState>({
+        players: {},
+        loading: false,
+    });
+    const fetchedRef = useRef<Set<string>>(new Set());
+
+    const fetchPlayers = useCallback(async (ids: string[]) => {
+        // Dedupe against already-fetched
+        const newIds = ids.filter(id => id && !fetchedRef.current.has(id));
+        if (newIds.length === 0) return;
+
+        setState(prev => ({ ...prev, loading: true }));
+        try {
+            const resp = await getPlayersByIds(newIds);
+            const map: Record<string, PublicPlayerProps> = {};
+            for (const p of resp.players) {
+                map[p.player_id] = p;
+                fetchedRef.current.add(p.player_id);
+            }
+            setState(prev => ({
+                players: { ...prev.players, ...map },
+                loading: false,
+            }));
+        } catch {
+            setState(prev => ({ ...prev, loading: false }));
+        }
+    }, []);
+
+    useEffect(() => {
+        if (player_ids.length > 0) {
+            fetchPlayers(player_ids);
+        }
+    }, [player_ids.join(','), fetchPlayers]);
+
+    return { ...state, fetchPlayers };
+};

package/src/hooks/useCalcuttaResults.ts

@@ -0,0 +1,58 @@
+import { useMemo } from 'react';
+import type {
+    CalcuttaRoundProps,
+    CalcuttaAuctionItemProps,
+    CalcuttaItemResultProps,
+    CalcuttaPayoutRuleProps,
+} from '@bettoredge/types';
+
+export interface RoundResultSummary {
+    round: CalcuttaRoundProps;
+    advanced_items: CalcuttaAuctionItemProps[];
+    eliminated_items: CalcuttaAuctionItemProps[];
+    payout_rule?: CalcuttaPayoutRuleProps;
+    total_payout: number;
+}
+
+export const useCalcuttaResults = (
+    rounds: CalcuttaRoundProps[],
+    items: CalcuttaAuctionItemProps[],
+    item_results: CalcuttaItemResultProps[],
+    payout_rules: CalcuttaPayoutRuleProps[]
+) => {
+    const roundSummaries = useMemo((): RoundResultSummary[] => {
+        return rounds.map(round => {
+            const roundResults = item_results.filter(r => r.round_number === round.round_number);
+            const advancedIds = roundResults.filter(r => r.result === 'advanced' || r.result === 'won').map(r => r.calcutta_auction_item_id);
+            const eliminatedIds = roundResults.filter(r => r.result === 'eliminated').map(r => r.calcutta_auction_item_id);
+
+            const rule = payout_rules.find(r => r.payout_type === 'round' && r.round_number === round.round_number);
+            const totalPayout = roundResults.reduce((sum, r) => sum + Number(r.payout_earned), 0);
+
+            return {
+                round,
+                advanced_items: items.filter(i => advancedIds.includes(i.calcutta_auction_item_id)),
+                eliminated_items: items.filter(i => eliminatedIds.includes(i.calcutta_auction_item_id)),
+                payout_rule: rule,
+                total_payout: totalPayout,
+            };
+        });
+    }, [rounds, items, item_results, payout_rules]);
+
+    const itemPerformance = useMemo(() => {
+        return items.map(item => {
+            const results = item_results.filter(r => r.calcutta_auction_item_id === item.calcutta_auction_item_id);
+            const totalEarned = results.reduce((sum, r) => sum + Number(r.payout_earned), 0);
+            const lastResult = results[results.length - 1];
+            return {
+                item,
+                results,
+                total_earned: totalEarned,
+                rounds_survived: results.filter(r => r.result === 'advanced' || r.result === 'won').length,
+                final_result: lastResult?.result,
+            };
+        });
+    }, [items, item_results]);
+
+    return { roundSummaries, itemPerformance };
+};

package/src/hooks/useCalcuttaSocket.ts

@@ -0,0 +1,131 @@
+import { useState, useEffect, useCallback, useRef } from 'react';
+import type {
+    CalcuttaCompetitionProps,
+    CalcuttaAuctionItemProps,
+    CalcuttaBidProps,
+} from '@bettoredge/types';
+
+export interface CalcuttaPresencePlayer {
+    player_id: string;
+    username?: string;
+    profile_pic?: string;
+}
+
+export interface CalcuttaPresence {
+    count: number;
+    players: CalcuttaPresencePlayer[];
+}
+
+export interface CalcuttaSocketCallbacks {
+    onBidUpdate?: (data: { item: CalcuttaAuctionItemProps; bid: CalcuttaBidProps; item_deadline?: string; escrow_snapshot?: any }) => void;
+    onItemActive?: (data: { item: CalcuttaAuctionItemProps; item_deadline?: string }) => void;
+    onItemSold?: (data: { item: CalcuttaAuctionItemProps; winning_bid: CalcuttaBidProps; winning_player_id: string }) => void;
+    onItemUnsold?: (data: { item: CalcuttaAuctionItemProps }) => void;
+    onAuctionPaused?: () => void;
+    onAuctionResumed?: (data: { item?: CalcuttaAuctionItemProps; item_deadline?: string }) => void;
+    onAuctionClosed?: (data: { competition: CalcuttaCompetitionProps }) => void;
+}
+
+export const useCalcuttaSocket = (
+    calcutta_competition_id: string,
+    player_data: { username: string; profile_pic?: string },
+    getSocket: () => WebSocket | null,
+    getAccessToken: () => string | undefined,
+    getDeviceId: () => string | undefined,
+    callbacks?: CalcuttaSocketCallbacks,
+) => {
+    const [connected, setConnected] = useState(false);
+    const [presence, setPresence] = useState<CalcuttaPresence>({ count: 0, players: [] });
+    const joinedRef = useRef(false);
+    const callbacksRef = useRef(callbacks);
+    callbacksRef.current = callbacks;
+
+    const handleMessage = useCallback((event: MessageEvent) => {
+        try {
+            const data = JSON.parse(event.data);
+            if (data.calcutta_competition_id && data.calcutta_competition_id !== calcutta_competition_id) return;
+
+            switch (data.type) {
+                case 'CALCUTTA_BID_UPDATE':
+                    callbacksRef.current?.onBidUpdate?.(data);
+                    break;
+                case 'CALCUTTA_ITEM_ACTIVE':
+                    callbacksRef.current?.onItemActive?.(data);
+                    break;
+                case 'CALCUTTA_ITEM_SOLD':
+                    callbacksRef.current?.onItemSold?.(data);
+                    break;
+                case 'CALCUTTA_ITEM_UNSOLD':
+                    callbacksRef.current?.onItemUnsold?.(data);
+                    break;
+                case 'CALCUTTA_AUCTION_PAUSED':
+                    callbacksRef.current?.onAuctionPaused?.();
+                    break;
+                case 'CALCUTTA_AUCTION_RESUMED':
+                    callbacksRef.current?.onAuctionResumed?.(data);
+                    break;
+                case 'CALCUTTA_AUCTION_CLOSED':
+                    callbacksRef.current?.onAuctionClosed?.(data);
+                    break;
+                case 'CALCUTTA_PRESENCE_UPDATE':
+                    setPresence({ count: data.count, players: data.players });
+                    break;
+                case 'V1_SOCKET_JOIN_CALCUTTA':
+                    if (data.status === 'success') {
+                        setConnected(true);
+                        if (data.count != null) {
+                            setPresence({ count: data.count, players: data.players || [] });
+                        }
+                    }
+                    break;
+            }
+        } catch {
+            // Ignore non-JSON or malformed messages
+        }
+    }, [calcutta_competition_id]);
+
+    useEffect(() => {
+        const ws = getSocket();
+        if (!ws || ws.readyState !== WebSocket.OPEN) return;
+
+        const access_token = getAccessToken();
+        const device_id = getDeviceId();
+        if (!access_token || !device_id) return;
+
+        // Add listener
+        // @ts-expect-error React Native WebSocket type lacks 'message' overload but it works at runtime
+        ws.addEventListener('message', handleMessage);
+
+        // Send join message
+        if (!joinedRef.current) {
+            ws.send(JSON.stringify({
+                type: 'JOIN_CALCUTTA_AUCTION',
+                access_token,
+                device_id,
+                calcutta_competition_id,
+                player_data,
+            }));
+            joinedRef.current = true;
+        }
+
+        return () => {
+            // @ts-expect-error React Native WebSocket type lacks 'message' overload but it works at runtime
+            ws.removeEventListener('message', handleMessage);
+
+            // Send leave message
+            if (joinedRef.current && ws.readyState === WebSocket.OPEN) {
+                ws.send(JSON.stringify({
+                    type: 'LEAVE_CALCUTTA_AUCTION',
+                    access_token,
+                    device_id,
+                    calcutta_competition_id,
+                }));
+                joinedRef.current = false;
+            }
+
+            setConnected(false);
+        };
+    }, [calcutta_competition_id, handleMessage, getSocket, getAccessToken, getDeviceId]);
+
+    return { connected, presence };
+};

package/src/hooks/useCalcuttaTemplates.ts

@@ -0,0 +1,36 @@
+import { useState, useEffect, useCallback } from 'react';
+import { getActiveCalcuttaTemplates } from '@bettoredge/api';
+import type { CalcuttaTemplateProps } from '@bettoredge/types';
+
+export interface CalcuttaTemplatesState {
+    loading: boolean;
+    templates: CalcuttaTemplateProps[];
+    error?: string;
+    refresh: () => void;
+}
+
+export const useCalcuttaTemplates = (): CalcuttaTemplatesState => {
+    const [loading, setLoading] = useState(true);
+    const [templates, setTemplates] = useState<CalcuttaTemplateProps[]>([]);
+    const [error, setError] = useState<string | undefined>();
+
+    const fetchTemplates = useCallback(async () => {
+        try {
+            setLoading(true);
+            setError(undefined);
+            const resp = await getActiveCalcuttaTemplates();
+            setTemplates(resp.templates || []);
+        } catch (e: any) {
+            setError(e.message || 'Unable to load templates');
+            setTemplates([]);
+        } finally {
+            setLoading(false);
+        }
+    }, []);
+
+    useEffect(() => {
+        fetchTemplates();
+    }, [fetchTemplates]);
+
+    return { loading, templates, error, refresh: fetchTemplates };
+};

package/src/index.ts

@@ -0,0 +1,74 @@
+/**
+ * @bettoredge/calcutta
+ *
+ * Calcutta auction competition components for BettorEdge applications
+ */
+
+// Components
+export { CalcuttaCard } from './components/CalcuttaCard';
+export type { CalcuttaCardProps } from './components/CalcuttaCard';
+export { CalcuttaDetail } from './components/CalcuttaDetail';
+export type { CalcuttaDetailProps } from './components/CalcuttaDetail';
+export { CalcuttaAuction } from './components/CalcuttaAuction';
+export type { CalcuttaAuctionProps } from './components/CalcuttaAuction';
+export { CalcuttaAuctionItem } from './components/CalcuttaAuctionItem';
+export type { CalcuttaAuctionItemComponentProps } from './components/CalcuttaAuctionItem';
+export { CalcuttaLeaderboard } from './components/CalcuttaLeaderboard';
+export type { CalcuttaLeaderboardProps } from './components/CalcuttaLeaderboard';
+export { CalcuttaPayoutPreview } from './components/CalcuttaPayoutPreview';
+export type { CalcuttaPayoutPreviewProps } from './components/CalcuttaPayoutPreview';
+export { CalcuttaBidInput } from './components/CalcuttaBidInput';
+export type { CalcuttaBidInputProps } from './components/CalcuttaBidInput';
+export { CalcuttaEscrow } from './components/CalcuttaEscrow';
+export type { CalcuttaEscrowComponentProps } from './components/CalcuttaEscrow';
+export { CalcuttaRoundResults } from './components/CalcuttaRoundResults';
+export type { CalcuttaRoundResultsProps } from './components/CalcuttaRoundResults';
+export { CalcuttaItemResults } from './components/CalcuttaItemResults';
+export type { CalcuttaItemResultsProps } from './components/CalcuttaItemResults';
+
+export { CalcuttaTemplateSelector } from './components/CalcuttaTemplateSelector';
+export type { CalcuttaTemplateSelectorProps } from './components/CalcuttaTemplateSelector';
+
+// Sealed Bid Components
+export { SealedBidAuction } from './components/sealed/SealedBidAuction';
+export { SealedBidHeader } from './components/sealed/SealedBidHeader';
+export { SealedBidStatusBar } from './components/sealed/SealedBidStatusBar';
+export { SealedBidTabBar } from './components/sealed/SealedBidTabBar';
+export type { SealedBidTab } from './components/sealed/SealedBidTabBar';
+export { SealedBidItemCard } from './components/sealed/SealedBidItemCard';
+export { SealedBidItemsTab } from './components/sealed/SealedBidItemsTab';
+export { SealedBidMyBidsTab } from './components/sealed/SealedBidMyBidsTab';
+export { SealedBidPlayersTab } from './components/sealed/SealedBidPlayersTab';
+export { SealedBidInfoTab } from './components/sealed/SealedBidInfoTab';
+export { EscrowBottomSheet } from './components/sealed/EscrowBottomSheet';
+export { AuctionResultsModal } from './components/sealed/AuctionResultsModal';
+
+// Hooks
+export { useCalcuttaTemplates } from './hooks/useCalcuttaTemplates';
+export type { CalcuttaTemplatesState } from './hooks/useCalcuttaTemplates';
+export { useCalcuttaCompetition } from './hooks/useCalcuttaCompetition';
+export type { CalcuttaCompetitionState } from './hooks/useCalcuttaCompetition';
+export { useCalcuttaAuction } from './hooks/useCalcuttaAuction';
+export type { CalcuttaAuctionState } from './hooks/useCalcuttaAuction';
+export { useCalcuttaBid } from './hooks/useCalcuttaBid';
+export type { CalcuttaBidState } from './hooks/useCalcuttaBid';
+export { useCalcuttaEscrow } from './hooks/useCalcuttaEscrow';
+export type { CalcuttaEscrowState } from './hooks/useCalcuttaEscrow';
+export { useCalcuttaResults } from './hooks/useCalcuttaResults';
+export type { RoundResultSummary } from './hooks/useCalcuttaResults';
+export { useCalcuttaSocket } from './hooks/useCalcuttaSocket';
+export type { CalcuttaPresence, CalcuttaPresencePlayer, CalcuttaSocketCallbacks } from './hooks/useCalcuttaSocket';
+export { useCalcuttaPlayers } from './hooks/useCalcuttaPlayers';
+export type { CalcuttaPlayersState } from './hooks/useCalcuttaPlayers';
+export { useCalcuttaItemImages } from './hooks/useCalcuttaItemImages';
+export type { ItemImageMap } from './hooks/useCalcuttaItemImages';
+
+// Helpers
+export { formatCurrency, formatPlace, getStatusLabel, getItemStatusColor, getBidStatusColor } from './helpers/formatting';
+export { calculatePayoutPreview, validatePayoutRules } from './helpers/payout';
+export { validateBidAmount, validateEscrowDeposit, validateEscrowWithdraw } from './helpers/validation';
+export { deriveLifecycleState, canBid, canManageEscrow, showResults } from './helpers/lifecycleState';
+export type { CalcuttaLifecycleState } from './helpers/lifecycleState';
+
+// Types
+export type { CalcuttaStatus, AuctionType, PayoutType } from './types';

package/src/types.ts

@@ -0,0 +1,31 @@
+import type {
+    CalcuttaCompetitionProps,
+    CalcuttaRoundProps,
+    CalcuttaAuctionItemProps,
+    CalcuttaBidProps,
+    CalcuttaParticipantProps,
+    CalcuttaEscrowProps,
+    CalcuttaPayoutRuleProps,
+    CalcuttaItemResultProps,
+    CalcuttaTemplateProps,
+    CalcuttaTemplateItemProps,
+    CalcuttaTemplateRoundProps,
+} from '@bettoredge/types';
+
+export type {
+    CalcuttaCompetitionProps,
+    CalcuttaRoundProps,
+    CalcuttaAuctionItemProps,
+    CalcuttaBidProps,
+    CalcuttaParticipantProps,
+    CalcuttaEscrowProps,
+    CalcuttaPayoutRuleProps,
+    CalcuttaItemResultProps,
+    CalcuttaTemplateProps,
+    CalcuttaTemplateItemProps,
+    CalcuttaTemplateRoundProps,
+};
+
+export type CalcuttaStatus = 'pending' | 'scheduled' | 'auction_open' | 'auction_closed' | 'inprogress' | 'closed';
+export type AuctionType = 'sealed_bid' | 'live';
+export type PayoutType = 'round' | 'placement' | 'both';