feat(web): add match views

This commit is contained in:
dahyeon committed 2026-04-24 02:17:00 +09:00
1 parent 2429715e14
commit 705790bdab
9 files changed
+7513

No files matched your search

+762
View File
@@ -0,0 +1,762 @@
import { InteractionStatus } from '@azure/msal-browser';
import { useMsal } from '@azure/msal-react';
import { useInfiniteQuery, useMutation, useQuery } from '@tanstack/react-query';
import { DEFAULT_COMMUNITY_ID, useAuthUserId } from '../config';
import { apiFetch } from '../lib/api';
import {
isMsalConfigured,
MSAL_API_SCOPE,
MSAL_SILENT_REDIRECT_URI,
} from '../lib/auth/msal.config';
import type {
ApiAuction,
ApiAuctionHistoryEntry,
ApiChampionStatsResponse,
ApiCommunity,
ApiEnqueueRefreshResult,
ApiInternalMatchDetailResponse,
ApiInternalMatchListResponse,
ApiLeaderboardResponse,
LegacyImportJobsResponse,
LegacyImportMembersResponse,
LegacyMatchListResponse,
ApiMatch,
ApiRecentMatchesResponse,
ApiRecentSummaryResponse,
ApiTeamInsightsResponse,
ApiTournamentCode,
ApiUserInternalHistoryResponse,
ApiUserHistoryProfile,
DdragonManifest,
StartLegacyImportRequest,
StartLegacyImportResponse,
MatchStatus,
MatchMutationRequest,
MatchesResponse,
ManualTournamentResultCollectResponse,
MeResponse,
RiotQueueGroup,
RiotRankFilter,
RebuildLegacyMatchesResponse,
TournamentCodeBulkUploadResponse,
TournamentCodeListResponse,
TournamentCodeState,
TournamentCodeStatsResponse,
TournamentCodeUploadItem,
} from './types';
const DDRAGON_MANIFEST_STALE_MS = 24 * 60 * 60 * 1000;
interface MatchesQueryOptions {
status?: MatchStatus;
limit?: number;
}
export interface UserHistoryFilters {
queueGroup?: RiotQueueGroup;
rank?: RiotRankFilter;
seasonId?: string;
championId?: number;
}
export interface CommunityInternalStatsFilters {
seasonId?: string;
from?: string;
to?: string;
championId?: number;
limit?: number;
}
function createMatchesPath(
communityId: string,
options: MatchesQueryOptions = {},
) {
const searchParams = new URLSearchParams();
if (options.status) searchParams.set('status', options.status);
if (options.limit) searchParams.set('limit', String(options.limit));
const queryString = searchParams.toString();
return `/communities/${communityId}/matches${queryString ? `?${queryString}` : ''}`;
}
export function useCommunity(communityId = DEFAULT_COMMUNITY_ID) {
return useQuery({
queryKey: ['community', communityId],
queryFn: () =>
apiFetch<ApiCommunity>(`/communities/${communityId}`, { auth: 'none' }),
enabled: Boolean(communityId),
});
}
export function useMatches(
options: MatchesQueryOptions,
communityId = DEFAULT_COMMUNITY_ID,
) {
return useQuery({
queryKey: ['matches', communityId, options.status ?? null, options.limit ?? null],
queryFn: async () => {
const response = await apiFetch<MatchesResponse>(
createMatchesPath(communityId, options),
{ auth: 'none' },
);
return response.matches;
},
enabled: Boolean(communityId),
});
}
export function useMatch(matchId: string | undefined, communityId = DEFAULT_COMMUNITY_ID) {
return useQuery({
queryKey: ['match', communityId, matchId ?? null],
queryFn: () =>
apiFetch<ApiMatch>(`/communities/${communityId}/matches/${matchId}`, {
auth: 'none',
}),
enabled: Boolean(communityId && matchId),
retry: false,
});
}
export function useAuction(
matchId: string | undefined,
communityId = DEFAULT_COMMUNITY_ID,
options: { refetchInterval?: number | false } = {},
) {
return useQuery({
queryKey: ['auction', communityId, matchId ?? null],
queryFn: () =>
apiFetch<ApiAuction>(
`/communities/${communityId}/matches/${matchId}/auction`,
{ auth: 'none' },
),
enabled: Boolean(communityId && matchId),
retry: false,
refetchInterval: options.refetchInterval,
});
}
export function useAuctionHistory(
matchId: string | undefined,
communityId = DEFAULT_COMMUNITY_ID,
options: { enabled?: boolean; refetchInterval?: number | false } = {},
) {
return useQuery({
queryKey: ['auction-history', communityId, matchId ?? null],
queryFn: () =>
apiFetch<ApiAuctionHistoryEntry[]>(
`/communities/${communityId}/matches/${matchId}/auction/history`,
),
enabled: Boolean(communityId && matchId && (options.enabled ?? true)),
retry: false,
refetchInterval: options.refetchInterval,
});
}
export function useUndoAuction(communityId = DEFAULT_COMMUNITY_ID) {
return useMutation({
mutationFn: ({
matchId,
sequence,
}: {
matchId: string;
sequence: number;
}) =>
apiFetch<ApiAuction>(
`/communities/${communityId}/matches/${matchId}/auction/undo`,
{
method: 'POST',
body: JSON.stringify({ sequence }),
},
),
});
}
export function useCreateMatch(communityId = DEFAULT_COMMUNITY_ID) {
return useMutation({
mutationFn: (body: MatchMutationRequest) =>
apiFetch<ApiMatch>(`/communities/${communityId}/matches`, {
method: 'POST',
body: JSON.stringify(body),
}),
});
}
export function useUpdateMatch(communityId = DEFAULT_COMMUNITY_ID) {
return useMutation({
mutationFn: ({ matchId, body }: { matchId: string; body: Partial<MatchMutationRequest> }) =>
apiFetch<ApiMatch>(`/communities/${communityId}/matches/${matchId}`, {
method: 'PATCH',
body: JSON.stringify(body),
}),
});
}
function createUserHistoryPath(
communityId: string,
userId: string,
resource: string,
filters: UserHistoryFilters = {},
extra: Record<string, string | number | null | undefined> = {},
) {
const searchParams = new URLSearchParams();
if (filters.queueGroup) searchParams.set('queueGroup', filters.queueGroup);
if (filters.rank) searchParams.set('rank', filters.rank);
if (filters.seasonId) searchParams.set('seasonId', filters.seasonId);
if (filters.championId) searchParams.set('championId', String(filters.championId));
for (const [key, value] of Object.entries(extra)) {
if (value !== null && value !== undefined && value !== '') {
searchParams.set(key, String(value));
}
}
const queryString = searchParams.toString();
return `/communities/${communityId}/users/${userId}/${resource}${queryString ? `?${queryString}` : ''}`;
}
export function useUserHistoryProfile(
userId: string | undefined,
communityId = DEFAULT_COMMUNITY_ID,
) {
return useQuery({
queryKey: ['user-history-profile', communityId, userId ?? null],
queryFn: () =>
apiFetch<ApiUserHistoryProfile>(
`/communities/${communityId}/users/${userId}/history-profile`,
{ auth: 'none' },
),
enabled: Boolean(communityId && userId),
retry: false,
});
}
export function useChampionStats(
userId: string | undefined,
filters: UserHistoryFilters,
communityId = DEFAULT_COMMUNITY_ID,
enabled = true,
) {
return useQuery({
queryKey: [
'user-champion-stats',
communityId,
userId ?? null,
filters.queueGroup ?? null,
filters.rank ?? null,
filters.seasonId ?? null,
],
queryFn: () =>
apiFetch<ApiChampionStatsResponse>(
createUserHistoryPath(communityId, userId ?? '', 'champion-stats', filters),
{ auth: 'none' },
),
enabled: Boolean(communityId && userId && enabled),
});
}
export function useRecentSummary(
userId: string | undefined,
filters: UserHistoryFilters,
communityId = DEFAULT_COMMUNITY_ID,
enabled = true,
) {
return useQuery({
queryKey: [
'user-recent-summary',
communityId,
userId ?? null,
filters.queueGroup ?? null,
filters.rank ?? null,
filters.seasonId ?? null,
filters.championId ?? null,
],
queryFn: () =>
apiFetch<ApiRecentSummaryResponse>(
createUserHistoryPath(communityId, userId ?? '', 'recent-summary', filters),
{ auth: 'none' },
),
enabled: Boolean(communityId && userId && enabled),
});
}
export function useRecentMatches(
userId: string | undefined,
filters: UserHistoryFilters,
communityId = DEFAULT_COMMUNITY_ID,
enabled = true,
) {
return useInfiniteQuery({
queryKey: [
'user-recent-matches',
communityId,
userId ?? null,
filters.queueGroup ?? null,
filters.rank ?? null,
filters.seasonId ?? null,
filters.championId ?? null,
],
queryFn: ({ pageParam }) =>
apiFetch<ApiRecentMatchesResponse>(
createUserHistoryPath(communityId, userId ?? '', 'recent-matches', filters, {
cursor: pageParam,
limit: 10,
}),
{ auth: 'none' },
),
initialPageParam: null as number | null,
getNextPageParam: (lastPage) => lastPage.nextCursor,
enabled: Boolean(communityId && userId && enabled),
});
}
function createCommunityInternalStatsPath(
communityId: string,
resource: string,
filters: CommunityInternalStatsFilters = {},
extra: Record<string, string | number | null | undefined> = {},
) {
const searchParams = new URLSearchParams();
if (filters.seasonId) searchParams.set('seasonId', filters.seasonId);
if (filters.from) searchParams.set('from', filters.from);
if (filters.to) searchParams.set('to', filters.to);
if (filters.championId) searchParams.set('championId', String(filters.championId));
if (filters.limit) searchParams.set('limit', String(filters.limit));
for (const [key, value] of Object.entries(extra)) {
if (value !== null && value !== undefined && value !== '') {
searchParams.set(key, String(value));
}
}
const queryString = searchParams.toString();
return `/communities/${communityId}/internal-stats/${resource}${queryString ? `?${queryString}` : ''}`;
}
export function useCommunityInternalStatsMatches(
filters: CommunityInternalStatsFilters,
communityId = DEFAULT_COMMUNITY_ID,
enabled = true,
) {
return useInfiniteQuery({
queryKey: [
'community-internal-stats-matches',
communityId,
filters.seasonId ?? null,
filters.from ?? null,
filters.to ?? null,
filters.championId ?? null,
filters.limit ?? null,
],
queryFn: ({ pageParam }) =>
apiFetch<ApiInternalMatchListResponse>(
createCommunityInternalStatsPath(communityId, 'matches', filters, {
cursor: pageParam,
}),
{ auth: 'none' },
),
initialPageParam: null as number | null,
getNextPageParam: (lastPage) => lastPage.nextCursor,
enabled: Boolean(communityId && enabled),
});
}
export function useCommunityLeaderboard(
filters: CommunityInternalStatsFilters,
communityId = DEFAULT_COMMUNITY_ID,
enabled = true,
) {
return useQuery({
queryKey: [
'community-internal-stats-leaderboard',
communityId,
filters.seasonId ?? null,
filters.from ?? null,
filters.to ?? null,
filters.championId ?? null,
],
queryFn: () =>
apiFetch<ApiLeaderboardResponse>(
createCommunityInternalStatsPath(communityId, 'leaderboard', filters),
{ auth: 'none' },
),
enabled: Boolean(communityId && enabled),
});
}
export function useTeamInsights(
filters: CommunityInternalStatsFilters,
communityId = DEFAULT_COMMUNITY_ID,
enabled = true,
) {
return useQuery({
queryKey: [
'community-internal-stats-team-insights',
communityId,
filters.seasonId ?? null,
filters.from ?? null,
filters.to ?? null,
filters.championId ?? null,
],
queryFn: () =>
apiFetch<ApiTeamInsightsResponse>(
createCommunityInternalStatsPath(communityId, 'team-insights', filters),
{ auth: 'none' },
),
enabled: Boolean(communityId && enabled),
});
}
export function useInternalMatchDetail(
matchId: string | undefined,
communityId = DEFAULT_COMMUNITY_ID,
) {
return useQuery({
queryKey: ['community-internal-stats-match', communityId, matchId ?? null],
queryFn: () =>
apiFetch<ApiInternalMatchDetailResponse>(
`/communities/${communityId}/internal-stats/match/${matchId}`,
{ auth: 'none' },
),
enabled: Boolean(communityId && matchId),
retry: false,
});
}
export function useUserInternalHistory(
userId: string | undefined,
filters: UserHistoryFilters,
communityId = DEFAULT_COMMUNITY_ID,
enabled = true,
) {
return useInfiniteQuery({
queryKey: [
'user-internal-history',
communityId,
userId ?? null,
filters.seasonId ?? null,
filters.championId ?? null,
],
queryFn: ({ pageParam }) =>
apiFetch<ApiUserInternalHistoryResponse>(
createUserHistoryPath(communityId, userId ?? '', 'internal-history', filters, {
cursor: pageParam,
limit: 10,
}),
{ auth: 'none' },
),
initialPageParam: null as number | null,
getNextPageParam: (lastPage) => lastPage.nextCursor,
enabled: Boolean(communityId && userId && enabled),
});
}
export function useRefreshUserHistory(
userId: string | undefined,
communityId = DEFAULT_COMMUNITY_ID,
) {
return useMutation({
mutationFn: (body: {
queueGroups: RiotQueueGroup[];
priority: 'high' | 'low';
}) =>
apiFetch<ApiEnqueueRefreshResult>(
`/communities/${communityId}/users/${userId}/refresh`,
{
method: 'POST',
body: JSON.stringify(body),
},
),
});
}
export function useDdragonManifest(locale = 'ko_KR') {
return useQuery({
queryKey: ['ddragon-manifest', locale],
queryFn: () =>
apiFetch<DdragonManifest>(
`/riot/ddragon/manifest?locale=${encodeURIComponent(locale)}`,
{ auth: 'none' },
),
staleTime: DDRAGON_MANIFEST_STALE_MS,
gcTime: DDRAGON_MANIFEST_STALE_MS,
refetchOnMount: false,
refetchOnReconnect: false,
});
}
export function useTournamentCodeStats(
communityId = DEFAULT_COMMUNITY_ID,
enabled = true,
) {
return useQuery({
queryKey: ['tournament-code-stats', communityId],
queryFn: () =>
apiFetch<TournamentCodeStatsResponse>(
`/communities/${communityId}/tournament-codes/stats`,
),
enabled: Boolean(communityId && enabled),
refetchInterval: enabled ? 30_000 : false,
retry: false,
});
}
export function useTournamentCodes(
options: { state?: TournamentCodeState; limit?: number },
communityId = DEFAULT_COMMUNITY_ID,
enabled = true,
) {
return useQuery({
queryKey: [
'tournament-codes',
communityId,
options.state ?? null,
options.limit ?? null,
],
queryFn: () => {
const searchParams = new URLSearchParams();
if (options.state) searchParams.set('state', options.state);
if (options.limit) searchParams.set('limit', String(options.limit));
const queryString = searchParams.toString();
return apiFetch<TournamentCodeListResponse>(
`/communities/${communityId}/tournament-codes${queryString ? `?${queryString}` : ''}`,
);
},
enabled: Boolean(communityId && enabled),
refetchInterval: enabled ? 30_000 : false,
retry: false,
});
}
export function useBulkUploadTournamentCodes(communityId = DEFAULT_COMMUNITY_ID) {
return useMutation({
mutationFn: (codes: TournamentCodeUploadItem[]) =>
apiFetch<TournamentCodeBulkUploadResponse>(
`/communities/${communityId}/tournament-codes`,
{
method: 'POST',
body: JSON.stringify({ codes }),
},
),
});
}
export function useRestoreTournamentCode(communityId = DEFAULT_COMMUNITY_ID) {
return useMutation({
mutationFn: (codeId: string) =>
apiFetch<ApiTournamentCode>(
`/communities/${communityId}/tournament-codes/${codeId}/release`,
{ method: 'POST' },
),
});
}
export function useDeleteTournamentCode(communityId = DEFAULT_COMMUNITY_ID) {
return useMutation({
mutationFn: (codeId: string) =>
apiFetch<void>(`/communities/${communityId}/tournament-codes/${codeId}`, {
method: 'DELETE',
}),
});
}
export function usePollTournamentResult(communityId = DEFAULT_COMMUNITY_ID) {
return useMutation({
mutationFn: (matchId: string) =>
apiFetch<{
jobId: string;
matchId: string;
priority: 'high' | 'low';
attempt: number;
expandedToAllPuuids: boolean;
}>(`/communities/${communityId}/matches/${matchId}/poll-tournament-result`, {
method: 'POST',
}),
});
}
export function useCollectTournamentResultByWindow(
communityId = DEFAULT_COMMUNITY_ID,
) {
return useMutation({
mutationFn: (params: {
matchId: string;
startTime: string;
endTime: string;
}) =>
apiFetch<ManualTournamentResultCollectResponse>(
`/communities/${communityId}/matches/${params.matchId}/poll-tournament-result/collect-by-window`,
{
method: 'POST',
body: JSON.stringify({
startTime: params.startTime,
endTime: params.endTime,
}),
},
),
});
}
export function useCollectTournamentResultByRiotMatch(
communityId = DEFAULT_COMMUNITY_ID,
) {
return useMutation({
mutationFn: (params: { matchId: string; riotMatchId: string }) =>
apiFetch<ManualTournamentResultCollectResponse>(
`/communities/${communityId}/matches/${params.matchId}/poll-tournament-result/collect-by-riot-match`,
{
method: 'POST',
body: JSON.stringify({ riotMatchId: params.riotMatchId }),
},
),
});
}
export function useLegacyImportMembers(
options: { windowStart?: string; windowEnd?: string },
communityId = DEFAULT_COMMUNITY_ID,
enabled = true,
) {
return useQuery({
queryKey: [
'legacy-import-members',
communityId,
options.windowStart ?? null,
options.windowEnd ?? null,
],
queryFn: () => {
const searchParams = new URLSearchParams();
if (options.windowStart) searchParams.set('windowStart', options.windowStart);
if (options.windowEnd) searchParams.set('windowEnd', options.windowEnd);
const queryString = searchParams.toString();
return apiFetch<LegacyImportMembersResponse>(
`/communities/${communityId}/legacy-import/members${queryString ? `?${queryString}` : ''}`,
);
},
enabled: Boolean(communityId && enabled),
});
}
export function useLegacyImportJobs(
communityId = DEFAULT_COMMUNITY_ID,
enabled = true,
) {
return useQuery({
queryKey: ['legacy-import-jobs', communityId],
queryFn: () =>
apiFetch<LegacyImportJobsResponse>(
`/communities/${communityId}/legacy-import-jobs?limit=10`,
),
enabled: Boolean(communityId && enabled),
refetchInterval: (query) =>
query.state.data?.jobs.some(
(job) => job.state === 'pending' || job.state === 'running',
)
? 5_000
: false,
});
}
export function useStartLegacyImport(communityId = DEFAULT_COMMUNITY_ID) {
return useMutation({
mutationFn: (body: StartLegacyImportRequest) =>
apiFetch<StartLegacyImportResponse>(
`/communities/${communityId}/legacy-import`,
{
method: 'POST',
body: JSON.stringify(body),
},
),
});
}
export function useCancelLegacyImport(communityId = DEFAULT_COMMUNITY_ID) {
return useMutation({
mutationFn: (jobId: string) =>
apiFetch<void>(
`/communities/${communityId}/legacy-import-jobs/${jobId}/cancel`,
{ method: 'POST' },
),
});
}
export function useLegacyMatches(
communityId = DEFAULT_COMMUNITY_ID,
enabled = true,
) {
return useInfiniteQuery({
queryKey: ['legacy-matches', communityId],
queryFn: ({ pageParam }) => {
const searchParams = new URLSearchParams({ limit: '50' });
if (pageParam) searchParams.set('cursor', String(pageParam));
return apiFetch<LegacyMatchListResponse>(
`/communities/${communityId}/legacy-matches?${searchParams.toString()}`,
);
},
initialPageParam: null as number | null,
getNextPageParam: (lastPage) => lastPage.nextCursor,
enabled: Boolean(communityId && enabled),
});
}
export function useDeleteMatch(communityId = DEFAULT_COMMUNITY_ID) {
return useMutation({
mutationFn: (matchId: string) =>
apiFetch<void>(`/communities/${communityId}/matches/${matchId}`, {
method: 'DELETE',
}),
});
}
export function useBulkDeleteLegacyMatches(communityId = DEFAULT_COMMUNITY_ID) {
return useMutation({
mutationFn: (matchIds: string[]) =>
apiFetch<{ deleted: number }>(
`/communities/${communityId}/legacy-matches/bulk-delete`,
{
method: 'POST',
body: JSON.stringify({ matchIds }),
},
),
});
}
export function useRebuildLegacyMatches(communityId = DEFAULT_COMMUNITY_ID) {
return useMutation({
mutationFn: () =>
apiFetch<RebuildLegacyMatchesResponse>(
`/communities/${communityId}/legacy-matches/rebuild`,
{ method: 'POST' },
),
});
}
export function useMe() {
const authUserId = useAuthUserId();
const { accounts, inProgress, instance } = useMsal();
const account = isMsalConfigured
? (instance.getActiveAccount() ?? accounts[0] ?? null)
: null;
const accountKey = account?.homeAccountId ?? null;
const isMsalReady =
!isMsalConfigured || inProgress === InteractionStatus.None;
return useQuery({
queryKey: ['me', authUserId, accountKey],
queryFn: async () => {
if (!account) {
return apiFetch<MeResponse>('/me');
}
const response = await instance.acquireTokenSilent({
account,
scopes: [MSAL_API_SCOPE],
redirectUri: MSAL_SILENT_REDIRECT_URI,
});
return apiFetch<MeResponse>('/me', {
headers: {
Authorization: `Bearer ${response.accessToken}`,
},
});
},
enabled: Boolean(authUserId || isMsalReady),
retry: false,
});
}
+528
View File
@@ -0,0 +1,528 @@
import type {
ApiAuction,
ApiAuctionPlayerSnapshot,
ApiAuctionTeam,
ApiMatch,
ApiMatchParticipant,
ApiPositionPreference,
ApiRiotLaneStats,
ApiRiotRecentStatsSummary,
ApiTierInfo,
MatchStatus,
Position,
RiotLane,
TournamentCodeSlotView,
} from "./types";
import { POSITION_ORDER, teamIndexLabel } from "../lib/league";
export interface ParticipantView {
id: string;
userId: string;
summonerName: string;
tag: string;
tier?: ApiTierInfo;
mainPosition: Position;
subPosition: Position;
profileIconId: number;
excluded?: boolean;
}
export interface TeamParticipantView extends ParticipantView {
assignedPosition: Position;
cost?: number;
}
export interface TeamView {
teamIndex: number;
name: string;
participants: TeamParticipantView[];
}
export interface MatchDetailView {
id: string;
title: string;
date: string;
time: string;
status: MatchStatus;
description: string;
map: string;
maxParticipants: number;
gameCount: number;
gameMode: ApiMatch["gameMode"];
tournamentCodes: TournamentCodeSlotView[];
joined: boolean;
participants: ParticipantView[];
teams: TeamView[];
result?: {
winner?: string;
winnerTeamIndex?: number;
riotMatchIds: string[];
games: Array<{
gameNumber: number;
riotMatchId: string;
blueTeamIndex: number;
redTeamIndex: number;
winnerTeamIndex: number;
winnerSide: "blue" | "red";
gameCreation: number;
gameDuration: number;
participants: Array<{
userId: string;
teamIndex: number;
side: "blue" | "red";
championId: number;
kills: number;
deaths: number;
assists: number;
win: boolean;
}>;
}>;
seriesResults: NonNullable<ApiMatch["result"]>["seriesResults"];
};
prizes: string[];
notices: string[];
schedule: { time: string; label: string }[];
}
export interface AuctionPlayerView extends ParticipantView {
passCount: number;
masteries: {
championId: number;
level: number;
points: number;
}[];
recentStats: {
overall: ApiRiotLaneStats;
byLane: Partial<Record<RiotLane, ApiRiotLaneStats>>;
primary: ApiRiotLaneStats | null;
primarySource: "lane" | "overall" | "none";
};
}
export interface AuctionTeamView {
teamIndex: number;
name: string;
captainUserId: string;
captainName: string;
points: number;
members: (AuctionPlayerView & {
assignedPosition: Position;
cost: number;
})[];
}
export interface AuctionStateView {
matchId: string;
phase: ApiAuction["phase"];
teams: AuctionTeamView[];
currentPlayer: AuctionPlayerView | null;
currentPlayerIndex: number;
totalPlayers: number;
auctionOrder: AuctionPlayerView[];
passedQueue: AuctionPlayerView[];
auctionRound: number;
bids: {
teamIndex: number;
amount: number;
timestamp: string;
}[];
currentBid: number;
currentBidder: { teamIndex: number } | null;
timer: number;
maxTimer: number;
bidExtensionSeconds: number;
deadline?: string;
}
const MAP_LABELS: Record<number, string> = {
11: "소환사의 협곡",
12: "칼바람 나락",
21: "소환사의 협곡",
22: "전략적 팀 전투",
};
const TIER_NAMES: Record<string, string> = {
IRON: "아이언",
BRONZE: "브론즈",
SILVER: "실버",
GOLD: "골드",
PLATINUM: "플래티넘",
EMERALD: "에메랄드",
DIAMOND: "다이아",
MASTER: "마스터",
GRANDMASTER: "그랜드마스터",
CHALLENGER: "챌린저",
};
const POSITION_TO_RIOT_LANE: Record<Position, RiotLane> = {
TOP: "TOP",
JGL: "JUNGLE",
MID: "MIDDLE",
ADC: "BOTTOM",
SUP: "UTILITY",
};
function createEmptyLaneStats(): ApiRiotLaneStats {
return {
games: 0,
wins: 0,
losses: 0,
avgKills: 0,
avgDeaths: 0,
avgAssists: 0,
avgCs: 0,
avgCsPerMin: 0,
mostPlayedChampionIds: [],
};
}
function createEmptyRecentStatsView(): AuctionPlayerView["recentStats"] {
return {
overall: createEmptyLaneStats(),
byLane: {},
primary: null,
primarySource: "none",
};
}
function sortPreferredPositions(preferredPositions: ApiPositionPreference[]) {
return [...preferredPositions].sort(
(left, right) => left.priority - right.priority,
);
}
function resolveMainAndSubPosition(
preferredPositions: ApiPositionPreference[],
) {
const sorted = sortPreferredPositions(preferredPositions);
return {
mainPosition: sorted[0]?.position ?? "MID",
subPosition: sorted[1]?.position ?? sorted[0]?.position ?? "MID",
};
}
function mapMatchParticipantToView(
participant: ApiMatchParticipant,
): ParticipantView {
const { mainPosition, subPosition } = resolveMainAndSubPosition(
participant.preferredPositions,
);
return {
id: participant.userId,
userId: participant.userId,
summonerName: participant.gameName ?? "알 수 없음",
tag: participant.tagLine ?? "----",
tier: participant.tier,
mainPosition,
subPosition,
profileIconId: participant.profileIconId ?? 0,
excluded: participant.excluded ?? false,
};
}
function mapAuctionPlayerToView(
player: ApiAuctionPlayerSnapshot,
): AuctionPlayerView {
const { mainPosition, subPosition } = resolveMainAndSubPosition(
player.preferredPositions,
);
const summary = player.recentStatsSummary;
const primary = pickPrimary(summary, mainPosition);
return {
id: player.userId,
userId: player.userId,
summonerName: player.gameName,
tag: player.tagLine,
tier: selectPrimaryTier(player.tiers),
mainPosition,
subPosition,
profileIconId: player.profileIconId,
passCount: player.passCount ?? 0,
masteries: player.masteries.slice(0, 5).map((mastery) => ({
championId: mastery.championId,
level: mastery.championLevel,
points: mastery.championPoints,
})),
recentStats: {
overall: summary?.overall ?? createEmptyLaneStats(),
byLane: summary?.byLane ?? {},
primary: primary.stats,
primarySource: primary.source,
},
};
}
function createFallbackParticipant(userId: string): ParticipantView {
return {
id: userId,
userId,
summonerName: `User ${userId.slice(-4)}`,
tag: "----",
mainPosition: "MID",
subPosition: "MID",
profileIconId: 0,
};
}
function mapAuctionTeamToView(
team: ApiAuctionTeam,
playerLookup: Map<string, AuctionPlayerView>,
participantLookup: Map<string, ParticipantView>,
): AuctionTeamView {
return {
teamIndex: team.teamIndex,
name: teamIndexLabel(team.teamIndex),
captainUserId: team.captainUserId,
captainName:
participantLookup.get(team.captainUserId)?.summonerName ??
`User ${team.captainUserId.slice(-4)}`,
points: team.points,
members: team.members.map((member) => {
const participant = participantLookup.get(member.userId);
const player =
playerLookup.get(member.userId) ??
(participant
? {
...participant,
passCount: 0,
masteries: [],
recentStats: createEmptyRecentStatsView(),
}
: {
...createFallbackParticipant(member.userId),
passCount: 0,
masteries: [],
recentStats: createEmptyRecentStatsView(),
});
return {
...player,
assignedPosition: member.assignedPosition,
cost: member.cost,
};
}),
};
}
export function mapIdToLabel(mapId: number) {
return MAP_LABELS[mapId] ?? `맵 #${mapId}`;
}
export function formatKoreanDate(dateLike: string | Date) {
const date = new Date(dateLike);
return {
date: new Intl.DateTimeFormat("ko-KR", {
year: "numeric",
month: "long",
day: "numeric",
weekday: "short",
}).format(date),
time: new Intl.DateTimeFormat("ko-KR", {
hour: "numeric",
minute: "2-digit",
}).format(date),
};
}
function pickPrimary(
summary: ApiRiotRecentStatsSummary | undefined,
mainPosition: Position,
): {
stats: ApiRiotLaneStats | null;
source: "lane" | "overall" | "none";
} {
if (!summary) {
return { stats: null, source: "none" };
}
const laneStats = summary.byLane[POSITION_TO_RIOT_LANE[mainPosition]];
if (laneStats && laneStats.games > 0) {
return { stats: laneStats, source: "lane" };
}
if (summary.overall.games > 0) {
return { stats: summary.overall, source: "overall" };
}
return { stats: null, source: "none" };
}
export function selectPrimaryTier(tiers: ApiTierInfo[]) {
return tiers.find((tier) => tier.queueType === "RANKED_SOLO_5x5") ?? tiers[0];
}
export function formatTierLabel(tier?: ApiTierInfo) {
if (!tier) return "미등록";
const tierName = TIER_NAMES[tier.tier] ?? tier.tier;
const highTier = ["MASTER", "GRANDMASTER", "CHALLENGER"].includes(tier.tier);
if (highTier && tier.leaguePoints > 0) {
return `${tierName} ${tier.leaguePoints}LP`;
}
return tier.rank ? `${tierName} ${tier.rank}` : tierName;
}
export function getTierColorToken(tier?: ApiTierInfo) {
switch (tier?.tier) {
case "CHALLENGER":
return "text-amber-400";
case "GRANDMASTER":
return "text-red-400";
case "MASTER":
return "text-fuchsia-400";
case "DIAMOND":
return "text-cyan-400";
case "EMERALD":
return "text-emerald-400";
case "PLATINUM":
return "text-teal-300";
case "GOLD":
return "text-yellow-400";
case "SILVER":
return "text-gray-300";
case "BRONZE":
return "text-amber-700";
case "IRON":
return "text-stone-400";
default:
return "text-base-content/50";
}
}
export function buildDefaultPreferredPositions() {
return POSITION_ORDER.map((position, index) => ({
position,
priority: index + 1,
}));
}
export function mapApiMatchToMatchDetail(match: ApiMatch): MatchDetailView {
const formattedDate = formatKoreanDate(match.scheduledAt);
const participants = match.participants.map(mapMatchParticipantToView);
const participantLookup = new Map(
participants.map((participant) => [participant.userId, participant]),
);
const teams = match.teams.map((team) => ({
teamIndex: team.teamIndex,
name: teamIndexLabel(team.teamIndex, team.name),
participants: team.members.map((member) => {
const participant =
participantLookup.get(member.userId) ??
createFallbackParticipant(member.userId);
return {
...participant,
assignedPosition: member.assignedPosition,
cost: member.cost,
};
}),
}));
const winnerTeam = match.result?.winnerTeamIndex
? teams.find((team) => team.teamIndex === match.result?.winnerTeamIndex)
: undefined;
return {
id: match._id,
title: match.title,
date: formattedDate.date,
time: formattedDate.time,
status: match.status,
description: match.description,
map: mapIdToLabel(match.mapId),
maxParticipants: match.maxParticipants,
gameCount: match.gameCount ?? 3,
gameMode: match.gameMode ?? "pair",
tournamentCodes: match.tournamentCodes ?? [],
joined: Boolean(match.joined),
participants,
teams,
result: match.result
? {
winner: match.result.winnerTeamIndex ? winnerTeam?.name : undefined,
winnerTeamIndex: match.result.winnerTeamIndex,
riotMatchIds: match.result.riotMatchIds,
games: [...(match.result.games ?? [])].sort(
(left, right) => left.gameNumber - right.gameNumber,
),
seriesResults: match.result.seriesResults ?? [],
}
: undefined,
prizes: match.prizes,
notices: match.notices,
schedule: match.schedule,
};
}
export function mapApiAuctionToAuctionState(
auction: ApiAuction,
match: ApiMatch,
now = new Date(),
): AuctionStateView {
const participantLookup = new Map(
match.participants
.map(mapMatchParticipantToView)
.map((participant) => [participant.userId, participant]),
);
const auctionOrder = auction.order.map(mapAuctionPlayerToView);
const passedQueue = (auction.passedQueue ?? []).map(mapAuctionPlayerToView);
const auctionPlayerLookup = new Map(
auctionOrder.map((player) => [player.userId, player]),
);
const teams = [...auction.teams].sort(
(left, right) => left.teamIndex - right.teamIndex,
);
const totalPlayers = auctionOrder.length;
const currentPlayer =
auction.phase === "complete"
? null
: (auctionPlayerLookup.get(
auction.order[auction.currentIndex]?.userId ?? "",
) ?? null);
const currentPlayerIndex =
auction.phase === "complete" ? totalPlayers : auction.currentIndex;
const timer = auction.currentDeadline
? Math.max(
0,
Math.ceil(
(new Date(auction.currentDeadline).getTime() - now.getTime()) / 1000,
),
)
: 0;
return {
matchId: auction.matchId,
phase: auction.phase,
teams: teams.map((team) =>
mapAuctionTeamToView(team, auctionPlayerLookup, participantLookup),
),
currentPlayer,
currentPlayerIndex,
totalPlayers,
auctionOrder,
passedQueue,
auctionRound: auction.auctionRound ?? 1,
bids: auction.bids.map((bid) => ({
teamIndex: bid.teamIndex,
amount: bid.amount,
timestamp: bid.timestamp,
})),
currentBid: auction.currentBid,
currentBidder: auction.currentBidderTeamIndex
? {
teamIndex: auction.currentBidderTeamIndex,
}
: null,
timer,
maxTimer: auction.maxTimerSeconds,
bidExtensionSeconds: auction.bidExtensionSeconds ?? 5,
deadline: auction.currentDeadline,
};
}
+853
View File
@@ -0,0 +1,853 @@
export type Position = 'TOP' | 'JGL' | 'MID' | 'ADC' | 'SUP';
export type RiotLane = 'TOP' | 'JUNGLE' | 'MIDDLE' | 'BOTTOM' | 'UTILITY';
export type TeamSide = 'blue' | 'red';
export type MatchGameMode = 'pair' | 'bracket' | 'round-robin';
export type MatchStatus =
| 'recruiting'
| 'team-built'
| 'in-progress'
| 'finished';
export type AuctionPhase =
| 'waiting'
| 'presenting'
| 'bidding'
| 'sold'
| 'passed'
| 'complete';
export type AuctionTopTierThreshold =
| 'NONE'
| 'EMERALD'
| 'DIAMOND'
| 'MASTER'
| 'MANUAL';
export type CommunityRole = 'owner' | 'admin' | 'member';
export interface ApiPositionPreference {
position: Position;
priority: number;
}
export interface ApiTierInfo {
queueType: string;
tier: string;
rank: string;
leaguePoints: number;
wins: number;
losses: number;
fetchedAt: string;
}
export interface ApiChampionMasteryEntry {
puuid?: string;
championId: number;
championLevel: number;
championPoints: number;
lastPlayTime?: number;
championPointsSinceLastLevel?: number;
championPointsUntilNextLevel?: number;
markRequiredForNextLevel?: number;
tokensEarned?: number;
championSeasonMilestone?: number;
milestoneGrades?: string[];
nextSeasonMilestone?: Record<string, unknown>;
}
export interface ApiRiotLaneStats {
games: number;
wins: number;
losses: number;
avgKills: number;
avgDeaths: number;
avgAssists: number;
avgCs: number;
avgCsPerMin: number;
mostPlayedChampionIds: number[];
}
export interface ApiRiotRecentStatsSummary {
overall: ApiRiotLaneStats;
byLane: Partial<Record<RiotLane, ApiRiotLaneStats>>;
}
export interface ApiRiotAccount {
puuid: string;
gameName: string;
tagLine: string;
profileIconId: number;
revisionDate: number;
summonerLevel: number;
isPrimary: boolean;
tiers: ApiTierInfo[];
tierHistory: unknown[];
matchIds: string[];
championMasteries: ApiChampionMasteryEntry[];
championRecords: Record<string, Record<string, unknown>>;
recentStatsSummary?: ApiRiotRecentStatsSummary;
createdAt: string;
updatedAt: string;
}
export interface ApiUser {
_id: string;
communityId: string;
identityId?: string;
role: CommunityRole;
kakaoTalkId?: string;
kakaoTalkNickname?: string;
discordId?: string;
discordNickname?: string;
riotAccounts: ApiRiotAccount[];
preferredPositions: ApiPositionPreference[];
isActivated: boolean;
createdAt: string;
updatedAt: string;
}
export interface ApiCommunity {
_id: string;
name: string;
description: string;
ownerUserId: string;
matchGameCount?: number;
createdAt: string;
updatedAt: string;
}
export type TournamentCodeState =
| 'available'
| 'reserved'
| 'used'
| 'expired'
| 'released';
export type TournamentCodeSlotState = TournamentCodeState | 'pending';
export interface TournamentCodeSlotView {
gameNumber: number;
teamAIndex: number;
teamBIndex: number;
code: string | null;
expiresAt: string | null;
state: TournamentCodeSlotState;
riotMatchId: string | null;
}
export interface ApiMatchParticipant {
userId: string;
puuid?: string;
gameName?: string;
tagLine?: string;
profileIconId?: number;
tier?: ApiTierInfo;
preferredPositions: ApiPositionPreference[];
joinedAt: string;
excluded?: boolean;
}
export interface ApiMatchTeamMember {
userId: string;
assignedPosition: Position;
cost?: number;
}
export interface ApiMatchTeam {
teamIndex: number;
name: string;
captainUserId?: string;
members: ApiMatchTeamMember[];
}
export interface ApiMatchGameResultParticipant {
userId: string;
teamIndex: number;
side: TeamSide;
championId: number;
kills: number;
deaths: number;
assists: number;
win: boolean;
}
export interface ApiMatchGameResult {
gameNumber: number;
riotMatchId: string;
blueTeamIndex: number;
redTeamIndex: number;
winnerTeamIndex: number;
winnerSide: TeamSide;
gameCreation: number;
gameDuration: number;
participants: ApiMatchGameResultParticipant[];
}
export interface ApiMatchResult {
winnerTeamIndex?: number;
mvpUserId?: string;
riotMatchIds: string[];
games: ApiMatchGameResult[];
seriesResults?: Array<{
teamAIndex: number;
teamBIndex: number;
teamAWins: number;
teamBWins: number;
winnerTeamIndex?: number;
}>;
}
export interface ApiMatchScheduleItem {
time: string;
label: string;
}
export interface ApiMatchGameAssignment {
gameNumber: number;
teamAIndex: number;
teamBIndex: number;
}
export interface ManualTournamentResultCollectResponse {
scanned: number;
matched: number;
skipped: number;
riotMatchIds: string[];
gameNumbers: number[];
}
export interface ApiMatch {
_id: string;
communityId: string;
shortCode?: string;
title: string;
description: string;
mapId: number;
status: MatchStatus;
scheduledAt: string;
maxParticipants: number;
gameCount: number;
gameMode: MatchGameMode;
gameSchedule?: ApiMatchGameAssignment[];
tournamentCodes?: TournamentCodeSlotView[];
hostUserId?: string;
participants: ApiMatchParticipant[];
teams: ApiMatchTeam[];
result?: ApiMatchResult;
prizes: string[];
notices: string[];
schedule: ApiMatchScheduleItem[];
joined?: boolean;
createdAt: string;
updatedAt: string;
}
export interface ApiAuctionPlayerSnapshot {
userId: string;
puuid: string;
gameName: string;
tagLine: string;
profileIconId: number;
preferredPositions: ApiPositionPreference[];
tiers: ApiTierInfo[];
masteries: ApiChampionMasteryEntry[];
recentStatsSummary?: ApiRiotRecentStatsSummary;
passCount: number;
}
export interface ApiAuctionTeamMember {
userId: string;
assignedPosition: Position;
cost: number;
}
export interface ApiAuctionTeam {
teamIndex: number;
captainUserId: string;
points: number;
members: ApiAuctionTeamMember[];
}
export interface ApiAuctionBid {
teamIndex: number;
amount: number;
bidderUserId: string;
timestamp: string;
}
export interface ApiAuction {
_id: string;
matchId: string;
phase: AuctionPhase;
teams: ApiAuctionTeam[];
order: ApiAuctionPlayerSnapshot[];
passedQueue: ApiAuctionPlayerSnapshot[];
auctionRound: number;
currentIndex: number;
bids: ApiAuctionBid[];
currentBid: number;
currentBidderTeamIndex?: number;
maxTimerSeconds: number;
bidExtensionSeconds: number;
currentDeadline?: string;
initialPoints: number;
topTierThreshold: AuctionTopTierThreshold;
manualTopTierUserIds: string[];
startedAt?: string;
completedAt?: string;
createdAt: string;
updatedAt: string;
}
export interface ApiAuctionHistoryEntry {
sequence: number;
action:
| 'start'
| 'open-bidding'
| 'bid'
| 'sold'
| 'passed'
| 'next'
| 'complete';
actionLabel: string;
takenAt: string;
}
export interface ApiIdentity {
id: string;
entraOid: string;
tenantId?: string;
email?: string;
displayName?: string;
}
export interface ApiMembership {
user: ApiUser;
community: ApiCommunity | null;
}
export interface MeResponse {
identity: ApiIdentity | null;
memberships: ApiMembership[];
}
export interface MatchesResponse {
matches: ApiMatch[];
}
export interface MatchMutationRequest {
title: string;
description?: string;
mapId?: number;
scheduledAt: string;
maxParticipants?: number;
gameCount?: number;
gameMode?: MatchGameMode;
prizes?: string[];
notices?: string[];
schedule?: ApiMatchScheduleItem[];
}
export interface DdragonChampionEntry {
key: string;
name: string;
}
export interface DdragonSummonerSpellEntry {
key: string;
name: string;
}
export interface DdragonRuneEntry {
id: number;
key: string;
icon: string;
name: string;
}
export interface DdragonRuneStyleEntry extends DdragonRuneEntry {
slots: Array<{ runes: DdragonRuneEntry[] }>;
}
export interface DdragonManifest {
version: string;
cdn: string;
locale: string;
champions: Record<string, DdragonChampionEntry>;
summonerSpells: Record<string, DdragonSummonerSpellEntry>;
runesReforged: DdragonRuneStyleEntry[];
fetchedAt: string;
}
export type TournamentSpectatorType = 'NONE' | 'LOBBYONLY' | 'ALL';
export interface ApiTournamentCode {
_id: string;
code: string;
region: string;
mapType: 'SUMMONERS_RIFT';
teamSize: number;
spectatorType: TournamentSpectatorType;
metadata?: Record<string, unknown>;
expiresAt: string;
state: TournamentCodeState;
matchId?: string;
gameNumber?: number;
reservedAt?: string;
usedAt?: string;
releasedAt?: string;
riotMatchId?: string;
uploadedBy: string;
uploadedAt: string;
source?: string;
notes?: string;
createdAt: string;
updatedAt: string;
}
export interface TournamentCodeStatsResponse {
byState: Record<TournamentCodeState, number>;
expiringSoon: number;
available: number;
}
export interface TournamentCodeListResponse {
codes: ApiTournamentCode[];
}
export interface TournamentCodeUploadItem {
code: string;
expiresAt: string;
spectatorType?: TournamentSpectatorType;
metadata?: Record<string, unknown>;
source?: string;
notes?: string;
}
export interface TournamentCodeBulkUploadResponse {
inserted: number;
duplicates: string[];
invalid: Array<{ code: string; reason: string }>;
}
export type RiotQueueGroup =
| 'all'
| 'summoners-rift'
| 'aram'
| 'urf'
| 'arena'
| 'internal';
export type RiotRankFilter = 'all' | 'solo' | 'flex' | 'normal';
export interface ApiHistorySeason {
id: string;
label: string;
startedAt: string | null;
endedAt: string | null;
}
export interface ApiUserHistoryProfile {
userId: string;
puuid: string;
gameName: string;
tagLine: string;
profileIconId: number;
summonerLevel: number;
tiers: ApiTierInfo[];
season: ApiHistorySeason;
seasons: ApiHistorySeason[];
lastFetchedAt: string | null;
}
export interface ApiChampionStatsRow {
championId: number;
games: number;
wins: number;
losses: number;
winRate: number;
avgKills: number;
avgDeaths: number;
avgAssists: number;
kda: number;
totalKills: number;
totalDeaths: number;
totalAssists: number;
doubleKills: number;
tripleKills: number;
quadraKills: number;
pentaKills: number;
avgCs: number;
avgCsPerMin: number;
}
export interface ApiChampionStatsResponse {
queueGroup: RiotQueueGroup;
rank: RiotRankFilter;
queueIds: number[];
season: ApiHistorySeason;
lastFetchedAt: string | null;
champions: ApiChampionStatsRow[];
totals: ApiChampionStatsRow;
}
export interface ApiRecentSummaryResponse {
windowSize: number;
winRate: number;
wins: number;
losses: number;
streak: { type: 'win' | 'loss'; count: number } | null;
kda: number;
avgKills: number;
avgDeaths: number;
avgAssists: number;
bestRating: {
rating: number | 'Perfect';
kills: number;
deaths: number;
assists: number;
matchId: string;
} | null;
positionRates: Partial<Record<RiotLane, number>>;
topChampions: Array<{
championId: number;
games: number;
winRate: number;
pickRate: number;
avgRating: number;
}>;
lastFetchedAt: string | null;
}
export interface ApiRecentMatchTeamParticipant {
puuid: string;
gameName: string;
tagLine: string;
championId: number;
championLevel: number;
teamPosition: string;
kills: number;
deaths: number;
assists: number;
items: number[];
trinket: number;
summonerSpells: [number, number];
perks: { primaryStyle?: number; subStyle?: number; keystone?: number };
totalCs: number;
csPerMin: number;
goldEarned: number;
damageDealtToChampions: number;
damageTaken: number;
visionScore: number;
wardsPlaced: number;
wardsKilled: number;
controlWardsBought: number;
}
export interface ApiRecentMatchTeam {
side: 100 | 200;
win: boolean;
objectives?: { baron?: number; dragon?: number; tower?: number };
participants: ApiRecentMatchTeamParticipant[];
}
export interface ApiRecentMatchView {
matchId: string;
queueId: number;
queueLabel: string;
gameCreation: number;
gameDuration: number;
win: boolean;
remake: boolean;
championId: number;
championLevel: number;
teamPosition: string;
kills: number;
deaths: number;
assists: number;
kda: number;
rating: number;
totalCs: number;
csPerMin: number;
killParticipation: number;
visionScore: number;
controlWardsBought: number;
wardsPlaced: number;
wardsKilled: number;
damageDealtToChampions: number;
damageTaken: number;
goldEarned: number;
items: number[];
trinket: number;
summonerSpells: [number, number];
perks: { primaryStyle?: number; subStyle?: number; keystone?: number };
teams: ApiRecentMatchTeam[];
}
export interface ApiRecentMatchesResponse {
matches: ApiRecentMatchView[];
nextCursor: number | null;
lastFetchedAt: string | null;
season: ApiHistorySeason;
}
export interface ApiInternalMatchCard {
matchId: string;
title: string;
scheduledAt: string;
status: 'finished' | 'in-progress';
gameCount: number;
winnerTeamIndex?: number;
seriesResults: Array<{
teamAIndex: number;
teamBIndex: number;
teamAWins: number;
teamBWins: number;
winnerTeamIndex?: number;
}>;
games: Array<{
gameNumber: number;
riotMatchId: string | null;
blueTeamIndex: number;
redTeamIndex: number;
winnerTeamIndex: number | null;
winnerSide: TeamSide | null;
gameDuration: number;
}>;
teams: Array<{
teamIndex: number;
name: string;
members: Array<{
userId: string;
summonerName: string;
profileIconId: number;
}>;
}>;
}
export interface ApiInternalMatchListResponse {
matches: ApiInternalMatchCard[];
nextCursor: number | null;
season: ApiHistorySeason;
}
export interface ApiLeaderboardRow {
userId: string;
summonerName: string;
profileIconId: number;
games: number;
wins: number;
losses: number;
winRate: number;
totalKills: number;
totalDeaths: number;
totalAssists: number;
kda: number;
avgGoldPerMin: number;
avgKillParticipation: number;
avgCsPerMin: number;
avgDamageShare: number;
avgVisionScore: number;
byLane: Partial<Record<RiotLane, { games: number; wins: number; kda: number }>>;
topChampions: Array<{ championId: number; games: number; winRate: number }>;
}
export interface ApiLeaderboardResponse {
rows: ApiLeaderboardRow[];
season: ApiHistorySeason;
}
export interface ApiLeaderHighlight {
metric: number;
userId: string;
summonerName: string;
championId?: number;
matchId?: string;
isSingleGame: boolean;
}
export interface ApiTeamInsightsResponse {
season: ApiHistorySeason;
sideWinRate: {
blue: number;
red: number;
bluePicks: number;
redPicks: number;
};
topKda: ApiLeaderHighlight | null;
mostKills: ApiLeaderHighlight | null;
topTeamGpm: ApiLeaderHighlight | null;
topKillParticipation: ApiLeaderHighlight | null;
bestFarm: ApiLeaderHighlight | null;
minGamesThreshold: number;
}
export interface ApiInternalMatchDetailResponse {
match: ApiInternalMatchCard;
games: Array<{
gameNumber: number;
riotMatchId: string;
gameCreation: number;
gameDuration: number;
teams: Array<{
teamIndex: number;
side: TeamSide;
win: boolean;
objectives: { baron: number; dragon: number; tower: number };
participants: Array<{
userId: string | null;
summonerName: string;
teamIndex: number;
side: TeamSide;
teamPosition: string;
championId: number;
kills: number;
deaths: number;
assists: number;
cs: number;
csPerMin: number;
gold: number;
gpm: number;
damageDealtToChampions: number;
damageShare: number;
killParticipation: number;
visionScore: number;
items: number[];
trinket: number;
summonerSpells: [number, number];
perks: { primaryStyle?: number; subStyle?: number; keystone?: number };
win: boolean;
}>;
}>;
}>;
}
export interface ApiUserInternalHistoryResponse {
season: ApiHistorySeason;
championStats: ApiChampionStatsResponse;
summary: ApiRecentSummaryResponse;
matches: ApiRecentMatchView[];
nextCursor: number | null;
lastFetchedAt: string | null;
}
export type LegacyImportJobState =
| 'pending'
| 'running'
| 'completed'
| 'failed'
| 'cancelled';
export interface LegacyImportMemberWindow {
userId: string;
puuid: string;
displayName: string;
gameName: string;
tagLine: string;
profileIconId: number;
isActivated: boolean;
startTime: string;
endTime: string;
}
export interface LegacyImportMembersResponse {
members: LegacyImportMemberWindow[];
}
export interface StartLegacyImportRequest {
windowStart?: string;
windowEnd?: string;
memberOverrides?: Array<{
userId: string;
startTime?: string;
endTime?: string;
}>;
}
export interface StartLegacyImportResponse {
jobId: string;
totalMembers: number;
etaSeconds: number;
}
export interface LegacyImportJob {
_id: string;
jobId: string;
communityId: string;
triggeredBy: string;
startedAt: string;
completedAt?: string;
state: LegacyImportJobState;
windowStart: string;
windowEnd: string;
memberOverrides: Array<{
userId: string;
puuid: string;
startTime: string;
endTime: string;
}>;
totalMembers: number;
processedMembers: number;
totalDiscoveredMatchIds: number;
totalImportedMatches: number;
totalSkippedDuplicate: number;
totalErrors: number;
averageMemberSeconds?: number;
errors?: Array<{
puuid?: string;
matchId?: string;
reason: string;
at: string;
}>;
}
export interface LegacyImportJobsResponse {
jobs: LegacyImportJob[];
}
export interface LegacyMatchListItem {
matchId: string;
title: string;
scheduledAt: string;
riotMatchId: string | null;
memberCount: number;
externalCount: number;
teamAIndex: number;
teamBIndex: number;
teamAWins: number;
teamBWins: number;
winnerTeamIndex?: number;
}
export interface LegacyMatchListResponse {
matches: LegacyMatchListItem[];
nextCursor: number | null;
}
export interface RebuildLegacyMatchesResponse {
scanned: number;
rebuilt: number;
normalizedTitles: number;
skippedMissingRaw: number;
skippedNoKnownParticipants: number;
}
export type ApiRiotJobPriority = 'high' | 'low';
export type ApiRiotJobState = 'queued' | 'processing' | 'completed' | 'failed';
export interface ApiEnqueueRefreshResult {
parentJobId: string;
subJobs: Array<{
jobId: string;
queueGroup: RiotQueueGroup;
alreadyQueued: boolean;
etaSeconds: number;
queuePosition: number;
}>;
totalEtaSeconds: number;
}
export interface ApiRiotRefreshEvent {
parentJobId: string;
jobId: string;
queueGroup: RiotQueueGroup;
puuid: string;
state: ApiRiotJobState;
error?: string;
}
+121
View File
@@ -0,0 +1,121 @@
import { useEffect, useRef, useState } from 'react';
import { io, type Socket } from 'socket.io-client';
import { API_BASE_URL, useAuthUserId } from '../config';
import { acquireAccessToken } from '../lib/auth/token-provider';
import type { ApiAuction, Position } from './types';
type ConnectionStatus =
| 'idle'
| 'connecting'
| 'connected'
| 'disconnected'
| 'error';
interface BidPayload {
teamIndex: number;
amount: number;
bidderUserId?: string;
}
export function useAuctionSocket(matchId: string | undefined) {
const authUserId = useAuthUserId();
const socketRef = useRef<Socket | null>(null);
const [auction, setAuction] = useState<ApiAuction | null>(null);
const [connectionStatus, setConnectionStatus] =
useState<ConnectionStatus>('idle');
const [error, setError] = useState<string | null>(null);
useEffect(() => {
if (!matchId) {
setAuction(null);
setConnectionStatus('idle');
return;
}
let disposed = false;
setConnectionStatus('connecting');
setError(null);
void (async () => {
const accessToken = await acquireAccessToken().catch((error) => {
console.warn('Failed to acquire socket access token:', error);
return null;
});
if (disposed) return;
const socket = io(`${API_BASE_URL}/auction`, {
transports: ['websocket'],
auth: accessToken
? { token: accessToken }
: authUserId
? { 'x-auth-user-id': authUserId }
: {},
});
socketRef.current = socket;
socket.on('connect', () => {
setConnectionStatus('connected');
socket.emit('join', { matchId });
});
socket.on('disconnect', () => {
setConnectionStatus('disconnected');
});
socket.on('state', (nextAuction: ApiAuction) => {
setAuction(nextAuction);
setError(null);
});
socket.on('error', (payload: { message?: string }) => {
setConnectionStatus('error');
setError(payload.message ?? '실시간 경매 연결 중 오류가 발생했습니다.');
});
})();
return () => {
disposed = true;
const socket = socketRef.current;
socket?.removeAllListeners();
socket?.disconnect();
socketRef.current = null;
setConnectionStatus('idle');
};
}, [authUserId, matchId]);
function emit(eventName: string, payload?: unknown) {
const socket = socketRef.current;
if (!socket || !socket.connected) {
setError('소켓이 아직 연결되지 않았습니다.');
return;
}
setError(null);
if (payload === undefined) {
socket.emit(eventName);
return;
}
socket.emit(eventName, payload);
}
return {
auction,
connectionStatus,
error,
placeBid(payload: BidPayload) {
emit('bid', payload);
},
openBidding() {
emit('open-bidding', {});
},
markSold(assignedPosition?: Position) {
emit('sold', assignedPosition ? { assignedPosition } : {});
},
next() {
emit('next', {});
},
};
}
+73
View File
@@ -0,0 +1,73 @@
import { useEffect, useRef, useState } from 'react';
import { io, type Socket } from 'socket.io-client';
import { API_BASE_URL } from '../config';
import type { ApiRiotRefreshEvent } from './types';
type ConnectionStatus =
| 'idle'
| 'connecting'
| 'connected'
| 'disconnected'
| 'error';
export function useRiotRefreshSocket({
puuid,
parentJobId,
onEvent,
}: {
puuid?: string;
parentJobId?: string;
onEvent: (event: ApiRiotRefreshEvent) => void;
}) {
const socketRef = useRef<Socket | null>(null);
const onEventRef = useRef(onEvent);
const [connectionStatus, setConnectionStatus] =
useState<ConnectionStatus>('idle');
const [error, setError] = useState<string | null>(null);
useEffect(() => {
onEventRef.current = onEvent;
}, [onEvent]);
useEffect(() => {
if (!puuid && !parentJobId) {
setConnectionStatus('idle');
return;
}
setConnectionStatus('connecting');
setError(null);
const socket = io(`${API_BASE_URL}/riot-refresh`, {
transports: ['websocket'],
});
socketRef.current = socket;
socket.on('connect', () => {
setConnectionStatus('connected');
socket.emit('subscribe', { puuid, parentJobId });
});
socket.on('disconnect', () => {
setConnectionStatus('disconnected');
});
socket.on('riot-refresh', (event: ApiRiotRefreshEvent) => {
onEventRef.current(event);
});
socket.on('error', (payload: { message?: string }) => {
setConnectionStatus('error');
setError(payload.message ?? '전적 갱신 소켓 연결 중 오류가 발생했습니다.');
});
return () => {
socket.removeAllListeners();
socket.disconnect();
socketRef.current = null;
setConnectionStatus('idle');
};
}, [parentJobId, puuid]);
return { connectionStatus, error };
}
File diff suppressed because it is too large. Load diff
File diff suppressed because it is too large. Load diff
@@ -0,0 +1,710 @@
import { useState } from "react";
import { ChevronDown, ChevronUp } from "lucide-react";
import { Link, useLocation, useParams } from "react-router";
import {
useDdragonManifest,
useMatch,
useUserHistoryProfile,
} from "../api/hooks";
import { formatKoreanDate, formatTierLabel } from "../api/mappers";
import type {
ApiMatch,
ApiMatchGameResult,
ApiMatchParticipant,
ApiTierInfo,
MatchGameMode,
Position,
TeamSide,
TournamentCodeSlotView,
} from "../api/types";
import { DEFAULT_COMMUNITY_ID } from "../config";
import { profileIconUrl } from "../lib/ddragon";
import { positionLabel, sideShortLabel, teamIndexLabel } from "../lib/league";
const GAME_MODE_LABEL: Record<MatchGameMode, string> = {
pair: "페어 매치",
bracket: "토너먼트",
"round-robin": "리그전",
};
function resultBadgeClass(won: boolean) {
return won
? "border-blue-500/20 bg-blue-500/10 text-blue-400"
: "border-red-500/20 bg-red-500/10 text-red-400";
}
function captainName(
team: ApiMatch["teams"][number] | undefined,
participantByUserId: Map<string, ApiMatchParticipant>,
) {
if (!team?.captainUserId) return undefined;
return participantByUserId.get(team.captainUserId)?.gameName;
}
function tierByQueue(tiers: ApiTierInfo[], queueType: string) {
return tiers.find((tier) => tier.queueType === queueType);
}
function normalizeRank(rank: string | undefined) {
switch (rank) {
case "I":
return "1";
case "II":
return "2";
case "III":
return "3";
case "IV":
return "4";
default:
return rank;
}
}
function formatRankTooltip(tier: ApiTierInfo | undefined) {
if (!tier) return "언랭크";
const highTier = ["MASTER", "GRANDMASTER", "CHALLENGER"].includes(tier.tier);
const normalizedTier = {
...tier,
rank: normalizeRank(tier.rank) ?? tier.rank,
};
const label = highTier
? formatTierLabel({ ...normalizedTier, leaguePoints: 0 })
: formatTierLabel(normalizedTier);
return `${label} - ${tier.leaguePoints}LP`;
}
function formatRankBadge(tier: ApiTierInfo | undefined) {
if (!tier) return "U";
const tierInitial =
tier.tier === "GRANDMASTER" ? "GM" : tier.tier.slice(0, 1);
const rank = normalizeRank(tier.rank);
return rank ? `${tierInitial}${rank}` : tierInitial;
}
function rankBadgeClass(tier: ApiTierInfo | undefined) {
switch (tier?.tier) {
case "CHALLENGER":
return "border-amber-500/60 bg-amber-100 text-amber-900 dark:border-amber-400/40 dark:bg-amber-400/20 dark:text-amber-200";
case "GRANDMASTER":
return "border-red-500/60 bg-red-100 text-red-800 dark:border-red-400/40 dark:bg-red-400/20 dark:text-red-200";
case "MASTER":
return "border-fuchsia-500/60 bg-fuchsia-100 text-fuchsia-800 dark:border-fuchsia-400/40 dark:bg-fuchsia-400/20 dark:text-fuchsia-200";
case "DIAMOND":
return "border-cyan-500/60 bg-cyan-100 text-cyan-800 dark:border-cyan-400/40 dark:bg-cyan-400/20 dark:text-cyan-200";
case "EMERALD":
return "border-emerald-500/60 bg-emerald-100 text-emerald-800 dark:border-emerald-400/40 dark:bg-emerald-400/20 dark:text-emerald-200";
case "PLATINUM":
return "border-teal-500/60 bg-teal-100 text-teal-800 dark:border-teal-400/40 dark:bg-teal-400/20 dark:text-teal-200";
case "GOLD":
return "border-amber-500/70 bg-amber-100 text-amber-900 dark:border-yellow-400/40 dark:bg-yellow-400/20 dark:text-yellow-200";
case "SILVER":
return "border-slate-400/60 bg-slate-100 text-slate-700 dark:border-slate-300/40 dark:bg-slate-300/15 dark:text-slate-200";
case "BRONZE":
return "border-orange-600/60 bg-orange-100 text-orange-800 dark:border-orange-500/40 dark:bg-orange-500/20 dark:text-orange-200";
case "IRON":
return "border-stone-500/60 bg-stone-100 text-stone-700 dark:border-stone-400/40 dark:bg-stone-400/15 dark:text-stone-300";
default:
return "border-base-content/30 bg-transparent text-base-content/50";
}
}
function RankBadge({ tier }: { tier?: ApiTierInfo }) {
const tooltip = formatRankTooltip(tier);
return (
<span className="tooltip tooltip-left" data-tip={tooltip}>
<span
className={`inline-flex h-[17px] min-w-[18px] shrink-0 items-center justify-center whitespace-nowrap rounded-[3px] border px-1 text-[10px] font-black leading-none ${rankBadgeClass(tier)}`}
aria-label={tooltip}
>
{formatRankBadge(tier)}
</span>
</span>
);
}
function SummonerStatsSummary({
assignedPosition,
fallbackTier,
userId,
}: {
assignedPosition?: Position;
fallbackTier?: ApiTierInfo;
userId?: string;
}) {
const profileQuery = useUserHistoryProfile(userId, DEFAULT_COMMUNITY_ID);
const tiers = profileQuery.data?.tiers ?? [];
const soloTier =
tierByQueue(tiers, "RANKED_SOLO_5x5") ??
(fallbackTier?.queueType === "RANKED_SOLO_5x5" ? fallbackTier : undefined);
const flexTier = tierByQueue(tiers, "RANKED_FLEX_SR");
return (
<div className="ml-auto flex min-w-[148px] shrink-0 flex-col items-end text-right leading-tight">
<div className="text-[11px] font-black text-primary">
{assignedPosition ? positionLabel[assignedPosition] : "-"}
</div>
<div className="mt-1 flex items-center justify-end gap-2 text-[10px] font-black text-base-content/35">
<span className="inline-flex items-center gap-1">
<span>SOLO</span>
<RankBadge tier={soloTier} />
</span>
<span className="inline-flex items-center gap-1">
<span>FLEX</span>
<RankBadge tier={flexTier} />
</span>
</div>
</div>
);
}
function TeamMemberScoutLine({
isCaptain,
member,
participant,
}: {
isCaptain?: boolean;
member: ApiMatch["teams"][number]["members"][number];
participant?: ApiMatchParticipant;
}) {
return (
<ParticipantLine
assignedPosition={member.assignedPosition}
isCaptain={isCaptain}
participant={participant}
/>
);
}
function ParticipantLine({
participant,
assignedPosition,
isCaptain,
}: {
participant?: ApiMatchParticipant;
assignedPosition?: Position;
isCaptain?: boolean;
}) {
const { data: ddragon } = useDdragonManifest();
const location = useLocation();
const historyBackTo = `${location.pathname}${location.search}${location.hash}`;
const name = participant?.gameName ?? "알 수 없는 참가자";
const tag = participant?.tagLine ?? "----";
const content = (
<>
<div className="h-8 w-8 shrink-0 overflow-hidden bg-base-content/10">
<img
src={profileIconUrl(ddragon, participant?.profileIconId ?? 0)}
alt=""
className="h-full w-full object-cover"
loading="lazy"
/>
</div>
<div className="min-w-0 flex-1">
<div className="flex min-w-0 items-center gap-2">
<span className="truncate text-sm font-bold text-base-content">
{name}
</span>
{isCaptain && (
<span className="shrink-0 border border-amber-500/20 bg-amber-500/10 px-1.5 py-0.5 text-[10px] font-bold text-amber-500">
팀장
</span>
)}
</div>
<div className="text-[11px] text-base-content/30">#{tag}</div>
</div>
<SummonerStatsSummary
assignedPosition={assignedPosition}
fallbackTier={participant?.tier}
userId={participant?.userId}
/>
</>
);
const className =
"flex items-center gap-3 border-b border-base-content/5 px-3 py-2 last:border-b-0";
if (participant?.userId) {
return (
<Link
to={`/users/${participant.userId}/history`}
state={{ backTo: historyBackTo }}
className={`${className} hover:bg-base-content/[0.025]`}
>
{content}
</Link>
);
}
return <div className={className}>{content}</div>;
}
function UpcomingGameCard({
expanded,
game,
isNext,
onToggle,
participantByUserId,
parsedTeamIndex,
slot,
teamByIndex,
}: {
expanded: boolean;
game?: ApiMatchGameResult;
isNext?: boolean;
onToggle: () => void;
participantByUserId: Map<string, ApiMatchParticipant>;
parsedTeamIndex: number;
slot: TournamentCodeSlotView;
teamByIndex: Map<number, ApiMatch["teams"][number]>;
}) {
const [copied, setCopied] = useState(false);
const opponentIndex =
slot.teamAIndex === parsedTeamIndex ? slot.teamBIndex : slot.teamAIndex;
const ourTeam = teamByIndex.get(parsedTeamIndex);
const opponentTeam = teamByIndex.get(opponentIndex);
const ourTeamName = teamIndexLabel(parsedTeamIndex, ourTeam?.name);
const opponentTeamName = teamIndexLabel(opponentIndex, opponentTeam?.name);
const ourCaptainName = captainName(ourTeam, participantByUserId);
const opponentCaptainName = captainName(opponentTeam, participantByUserId);
const opponentMembers = opponentTeam?.members ?? [];
const finished = Boolean(game?.winnerTeamIndex);
const won = finished && game?.winnerTeamIndex === parsedTeamIndex;
const ourSide: TeamSide =
slot.teamAIndex === parsedTeamIndex ? "blue" : "red";
async function handleCopy() {
if (!slot.code) return;
try {
await navigator.clipboard.writeText(slot.code);
setCopied(true);
window.setTimeout(() => setCopied(false), 1500);
} catch {
setCopied(false);
}
}
return (
<li
className={`w-full border bg-base-100 p-4 ${
isNext
? "border-primary/30 bg-primary/[0.03]"
: "border-base-content/10"
} ${finished ? "bg-base-content/[0.015]" : ""}`}
>
<div className="flex items-center justify-between gap-2">
<div className="flex items-center gap-2">
<span
className={`border px-2 py-1 text-[11px] font-black ${
isNext
? "border-primary/25 bg-primary/10 text-primary"
: "border-base-content/10 bg-base-content/5 text-base-content/55"
}`}
>
{isNext ? "다음 경기" : `${slot.gameNumber}경기`}
</span>
<span className="text-[11px] font-semibold text-base-content/35">
{sideShortLabel(ourSide)}
</span>
</div>
{finished ? (
<div className="flex items-center gap-2">
<span
className={`border px-2 py-1 text-[11px] font-black ${resultBadgeClass(won)}`}
>
{won ? "승리" : "패배"}
</span>
<button
type="button"
className="inline-flex h-7 w-7 items-center justify-center text-base-content/45 hover:text-primary"
onClick={onToggle}
aria-expanded={expanded}
aria-label={expanded ? "상대팀 정보 접기" : "상대팀 정보 펼치기"}
>
{expanded ? (
<ChevronUp className="h-4 w-4" aria-hidden="true" />
) : (
<ChevronDown className="h-4 w-4" aria-hidden="true" />
)}
</button>
</div>
) : (
<button
type="button"
className="inline-flex h-7 w-7 items-center justify-center text-base-content/45 hover:text-primary"
onClick={onToggle}
aria-expanded={expanded}
aria-label={expanded ? "상대팀 정보 접기" : "상대팀 정보 펼치기"}
>
{expanded ? (
<ChevronUp className="h-4 w-4" aria-hidden="true" />
) : (
<ChevronDown className="h-4 w-4" aria-hidden="true" />
)}
</button>
)}
</div>
<div className="mt-4 grid grid-cols-[1fr_auto_1fr] items-start gap-2">
<div className="min-w-0">
<div className="truncate text-sm font-black text-primary">
{ourTeamName}
</div>
{ourCaptainName && (
<div className="mt-1 truncate text-[11px] text-base-content/35">
팀장 {ourCaptainName}
</div>
)}
</div>
<div className="pt-0.5 text-[10px] font-black uppercase tracking-wider text-base-content/25">
vs
</div>
<div className="min-w-0 text-right">
<div className="truncate text-sm font-bold text-base-content/70">
{opponentTeamName}
</div>
{opponentCaptainName && (
<div className="mt-1 truncate text-[11px] text-base-content/35">
팀장 {opponentCaptainName}
</div>
)}
</div>
</div>
<div className="mt-4 border border-base-content/8 bg-base-content/[0.02] px-3 py-2">
<div className="text-[10px] font-black uppercase tracking-wider text-base-content/35">
토너먼트 코드
</div>
<div className="mt-1 flex items-center gap-2">
{slot.code ? (
<>
<code className="min-w-0 flex-1 truncate font-mono text-[12px] font-black text-primary">
{slot.code}
</code>
<button
type="button"
className="border border-base-content/10 px-2 py-1 text-[10px] font-bold text-base-content/45 hover:text-primary"
onClick={handleCopy}
>
{copied ? "복사됨" : "복사"}
</button>
</>
) : (
<span className="text-[12px] font-semibold text-base-content/30">
발급 대기
</span>
)}
</div>
</div>
{expanded && (
<div className="mt-3 border border-base-content/8 bg-base-content/[0.015]">
<div className="flex items-center justify-between gap-2 border-b border-base-content/8 px-3 py-2">
<div>
<div className="text-[11px] font-black text-base-content/55">
상대팀 멤버
</div>
<div className="mt-0.5 text-[10px] text-base-content/30">
라인 · 티어
</div>
</div>
<div className="truncate text-right text-[11px] font-bold text-base-content/45">
{opponentTeamName}
</div>
</div>
{opponentMembers.length > 0 ? (
<div>
{opponentMembers.map((member) => (
<TeamMemberScoutLine
key={member.userId}
isCaptain={opponentTeam?.captainUserId === member.userId}
member={member}
participant={participantByUserId.get(member.userId)}
/>
))}
</div>
) : (
<div className="px-3 py-5 text-center text-xs text-base-content/30">
상대팀 멤버 정보가 아직 없습니다.
</div>
)}
</div>
)}
{finished && game?.riotMatchId && (
<div className="mt-2 truncate font-mono text-[10px] text-base-content/25">
{game.riotMatchId}
</div>
)}
</li>
);
}
function TeamGameCardsSection({
defaultExpandedGameNumber,
emptyMessage,
gameByNumber,
isPreTeamBuilt,
match,
participantByUserId,
parsedTeamIndex,
teamByIndex,
slots,
title,
}: {
defaultExpandedGameNumber?: number | null;
emptyMessage: string;
gameByNumber: Map<number, ApiMatchGameResult>;
isPreTeamBuilt?: boolean;
match: ApiMatch;
participantByUserId: Map<string, ApiMatchParticipant>;
parsedTeamIndex: number;
teamByIndex: Map<number, ApiMatch["teams"][number]>;
slots: TournamentCodeSlotView[];
title: string;
}) {
const formatted = formatKoreanDate(match.scheduledAt);
const [expandedGameNumber, setExpandedGameNumber] = useState<number | null>(
defaultExpandedGameNumber ?? null,
);
const nextGameNumber = defaultExpandedGameNumber ?? null;
return (
<section className="mb-4 border border-base-content/10 bg-base-100">
<div className="flex flex-col gap-1 border-b border-base-content/10 bg-base-200/40 px-4 py-3 sm:flex-row sm:items-center sm:justify-between">
<h2 className="text-[11px] font-bold uppercase tracking-wider text-base-content/40">
{title}
</h2>
<div className="sm:text-right">
<div className="text-sm font-black text-base-content/70">
{formatted.date} {formatted.time}
</div>
<div className="mt-0.5 text-[11px] font-semibold text-base-content/35">
{GAME_MODE_LABEL[match.gameMode]}
</div>
</div>
</div>
<div className="p-4">
{isPreTeamBuilt ? (
<div className="border border-dashed border-base-content/10 px-4 py-8 text-center text-xs text-base-content/35">
팀 빌딩이 끝나면 일정이 표시됩니다.
</div>
) : slots.length === 0 ? (
<div className="border border-dashed border-base-content/10 px-4 py-8 text-center text-xs text-base-content/35">
{emptyMessage}
</div>
) : (
<ul className="space-y-3">
{slots.map((slot) => (
<UpcomingGameCard
key={slot.gameNumber}
expanded={expandedGameNumber === slot.gameNumber}
game={gameByNumber.get(slot.gameNumber)}
isNext={slot.gameNumber === nextGameNumber}
onToggle={() =>
setExpandedGameNumber((current) =>
current === slot.gameNumber ? null : slot.gameNumber,
)
}
participantByUserId={participantByUserId}
parsedTeamIndex={parsedTeamIndex}
slot={slot}
teamByIndex={teamByIndex}
/>
))}
</ul>
)}
</div>
</section>
);
}
function buildFinishedSlot(
game: ApiMatchGameResult,
slotByGameNumber: Map<number, TournamentCodeSlotView>,
): TournamentCodeSlotView {
const slot = slotByGameNumber.get(game.gameNumber);
return {
gameNumber: game.gameNumber,
teamAIndex: game.blueTeamIndex,
teamBIndex: game.redTeamIndex,
code: slot?.code ?? null,
expiresAt: slot?.expiresAt ?? null,
state: slot?.state ?? "used",
riotMatchId: slot?.riotMatchId ?? game.riotMatchId,
};
}
export default function MatchTeamProgressPage() {
const { id, teamIndex } = useParams();
const parsedTeamIndex = Number(teamIndex);
const matchQuery = useMatch(id, DEFAULT_COMMUNITY_ID);
if (!DEFAULT_COMMUNITY_ID) {
return (
<main className="mx-auto max-w-5xl px-4 py-20 text-center text-sm text-amber-600">
`VITE_DEFAULT_COMMUNITY_ID` 설정이 필요합니다.
</main>
);
}
if (matchQuery.isLoading) {
return (
<main className="mx-auto max-w-5xl px-4 py-20 text-center text-sm text-base-content/40">
팀 진행 정보를 불러오는 중...
</main>
);
}
if (
!Number.isInteger(parsedTeamIndex) ||
parsedTeamIndex < 1 ||
!matchQuery.data
) {
return (
<main className="mx-auto max-w-5xl px-4 py-20 text-center">
<h1 className="text-lg font-bold">팀 정보를 찾을 수 없습니다</h1>
<Link
to={`/match/${id}`}
className="btn btn-primary btn-sm mt-4 px-5 text-xs"
>
내전 상세로
</Link>
</main>
);
}
const match = matchQuery.data;
const team = match.teams.find((item) => item.teamIndex === parsedTeamIndex);
const participantByUserId = new Map(
match.participants.map((participant) => [participant.userId, participant]),
);
const slotByGameNumber = new Map(
(match.tournamentCodes ?? []).map((slot) => [slot.gameNumber, slot]),
);
const codes = (match.tournamentCodes ?? []).filter(
(slot) =>
slot.teamAIndex === parsedTeamIndex ||
slot.teamBIndex === parsedTeamIndex,
);
const upcomingSlots = [...codes].sort(
(left, right) => left.gameNumber - right.gameNumber,
);
const teamByIndex = new Map(
match.teams.map((team) => [team.teamIndex, team]),
);
const gameByNumber = new Map(
(match.result?.games ?? []).map((game) => [game.gameNumber, game]),
);
const isPreTeamBuilt =
match.status === "recruiting" || (match.teams ?? []).length === 0;
const teamGames = (match.result?.games ?? []).filter(
(game) =>
game.blueTeamIndex === parsedTeamIndex ||
game.redTeamIndex === parsedTeamIndex,
);
const finishedSlots = teamGames
.filter((game) => Boolean(game.winnerTeamIndex))
.map((game) => buildFinishedSlot(game, slotByGameNumber))
.sort((left, right) => left.gameNumber - right.gameNumber);
const activeSlots = upcomingSlots.filter(
(slot) => !gameByNumber.get(slot.gameNumber)?.winnerTeamIndex,
);
if (!team) {
return (
<main className="mx-auto max-w-5xl px-4 py-20 text-center">
<h1 className="text-lg font-bold">아직 팀이 생성되지 않았습니다</h1>
<p className="mt-2 text-sm text-base-content/40">
경매가 완료되면 팀별 진행 페이지를 사용할 수 있습니다.
</p>
<Link
to={`/match/${id}`}
className="btn btn-primary btn-sm mt-4 px-5 text-xs"
>
내전 상세로
</Link>
</main>
);
}
return (
<main className="mx-auto max-w-5xl px-4 py-6 sm:px-6">
<Link
to={`/match/${id}`}
className="mb-5 inline-flex text-xs text-base-content/40 hover:text-base-content"
>
← 내전 상세로
</Link>
<div className="mb-6 border-b border-base-content/8 pb-5">
<h1 className="text-2xl font-black text-base-content">
{teamIndexLabel(team.teamIndex, team.name)}
</h1>
<p className="mt-1 text-sm text-base-content/45">
이 팀의 다가오는 경기 일정과 결과를 한곳에서 확인합니다.
</p>
</div>
<TeamGameCardsSection
defaultExpandedGameNumber={activeSlots[0]?.gameNumber ?? null}
emptyMessage="남은 경기가 없습니다."
gameByNumber={gameByNumber}
isPreTeamBuilt={isPreTeamBuilt}
match={match}
participantByUserId={participantByUserId}
parsedTeamIndex={parsedTeamIndex}
teamByIndex={teamByIndex}
slots={activeSlots}
title="다가오는 경기"
/>
<TeamGameCardsSection
defaultExpandedGameNumber={null}
emptyMessage="아직 종료된 경기가 없습니다."
gameByNumber={gameByNumber}
match={match}
participantByUserId={participantByUserId}
parsedTeamIndex={parsedTeamIndex}
teamByIndex={teamByIndex}
slots={finishedSlots}
title="종료된 경기"
/>
<section className="border border-base-content/10 bg-base-100">
<div className="border-b border-base-content/10 bg-base-200/40 px-4 py-2">
<h2 className="text-[11px] font-bold uppercase tracking-wider text-base-content/40">
팀 구성
</h2>
</div>
<ParticipantLine
participant={
team.captainUserId
? participantByUserId.get(team.captainUserId)
: undefined
}
isCaptain
/>
{team.members.map((member) => (
<ParticipantLine
key={member.userId}
participant={participantByUserId.get(member.userId)}
assignedPosition={member.assignedPosition}
/>
))}
</section>
</main>
);
}
File diff suppressed because it is too large. Load diff