fork/replay-manager-for-slippi

git clone https://git.julia.blue/fork/replay-manager-for-slippi

NicoletMerge pull request #167 from HannahConnolly/mainddc617a

2.5.1
11.3 KiB453 linesraw
1import styled from '@emotion/styled';
2import {
3  Box,
4  CircularProgress,
5  Collapse,
6  IconButton,
7  ListItemButton,
8  Tooltip,
9  Typography,
10} from '@mui/material';
11import {
12  KeyboardArrowDown,
13  KeyboardArrowRight,
14  KeyboardArrowUp,
15  Refresh,
16} from '@mui/icons-material';
17import { useState } from 'react';
18import { Phase, Tournament, Event } from '@parry-gg/client';
19import {
20  State,
21  ParryggBracket,
22  Set,
23  SetWithNames,
24  SelectedPhaseGroup,
25  SelectedPhase,
26  SelectedEvent,
27} from '../common/types';
28import SetViewInner from './SetView';
29import filterSets from './filterSets';
30
31const Block = styled.div`
32  padding-left: 8px;
33`;
34
35const Name = styled.div`
36  overflow-x: hidden;
37  text-overflow: ellipsis;
38  white-space: nowrap;
39`;
40
41function SetView({
42  setWithNames,
43  vlerkMode,
44  selectSet,
45}: {
46  setWithNames: SetWithNames;
47  vlerkMode: boolean;
48  selectSet: () => Promise<void>;
49}) {
50  const {
51    set: {
52      entrant1Id,
53      entrant1Score,
54      entrant2Score,
55      winnerId,
56      fullRoundText,
57      state,
58      stream,
59      station,
60      updatedAtMs,
61    },
62    entrant1Names,
63    entrant2Names,
64  } = setWithNames;
65  const isCompleted = state === State.COMPLETED;
66
67  return (
68    <ListItemButton
69      dense
70      disableGutters
71      onClick={() => {
72        selectSet();
73      }}
74    >
75      <SetViewInner
76        entrant1Names={entrant1Names}
77        entrant1Score={entrant1Score}
78        entrant1Win={entrant1Id === winnerId}
79        entrant2Names={entrant2Names}
80        entrant2Score={entrant2Score}
81        fullRoundText={fullRoundText}
82        showScores={isCompleted}
83        state={state}
84        stream={stream}
85        station={station}
86        wasReported={vlerkMode && isCompleted}
87        updatedAtMs={updatedAtMs}
88      />
89    </ListItemButton>
90  );
91}
92
93function BracketView({
94  bracket,
95  initiallyOpen,
96  searchSubstr,
97  vlerkMode,
98  getBracket,
99  selectSet,
100}: {
101  bracket: ParryggBracket;
102  initiallyOpen: boolean;
103  searchSubstr: string;
104  vlerkMode: boolean;
105  getBracket: (id: string) => Promise<void>;
106  selectSet: (set: Set) => Promise<void>;
107}) {
108  const [getting, setGetting] = useState(false);
109  const [completedOpen, setCompletedOpen] = useState(vlerkMode);
110  const [open, setOpen] = useState(initiallyOpen);
111
112  const get = async () => {
113    setGetting(true);
114    await getBracket(bracket.id);
115    setGetting(false);
116  };
117
118  const pendingSetsToShow = filterSets(
119    bracket.sets?.pendingSets ?? [],
120    searchSubstr,
121  );
122  const completedSetsToShow = filterSets(
123    bracket.sets?.completedSets ?? [],
124    searchSubstr,
125  );
126
127  return (
128    (!searchSubstr ||
129      pendingSetsToShow.length > 0 ||
130      completedSetsToShow.length > 0) && (
131      <>
132        <ListItemButton
133          dense
134          disableGutters
135          onClick={() => {
136            if (!open && bracket.matchesList.length === 0) {
137              get();
138            }
139            setOpen(!open);
140          }}
141          sx={{ typography: 'caption' }}
142        >
143          {open ? <KeyboardArrowDown /> : <KeyboardArrowRight />}
144          <Name>Bracket ({bracket.slug})</Name>
145          <Tooltip arrow title="Refresh bracket">
146            <IconButton
147              disabled={getting}
148              onClick={(event) => {
149                event.stopPropagation();
150                get();
151              }}
152              size="small"
153            >
154              {getting ? <CircularProgress size="24px" /> : <Refresh />}
155            </IconButton>
156          </Tooltip>
157        </ListItemButton>
158        <Collapse in={open}>
159          <div style={{ marginLeft: '-16px' }}>
160            {pendingSetsToShow.map((setWithNames) => {
161              const { set } = setWithNames;
162              return (
163                <SetView
164                  key={set.id}
165                  setWithNames={setWithNames}
166                  vlerkMode={vlerkMode}
167                  selectSet={() => selectSet(set)}
168                />
169              );
170            })}
171            {completedSetsToShow.length > 0 && (
172              <>
173                <ListItemButton
174                  dense
175                  onClick={() => setCompletedOpen(!completedOpen)}
176                >
177                  <Typography
178                    alignItems="center"
179                    display="flex"
180                    justifyContent="right"
181                    variant="subtitle2"
182                    width="100%"
183                  >
184                    completed
185                    {completedOpen ? (
186                      <KeyboardArrowUp />
187                    ) : (
188                      <KeyboardArrowDown />
189                    )}
190                  </Typography>
191                </ListItemButton>
192                <Collapse in={completedOpen}>
193                  {completedSetsToShow.map((setWithNames) => {
194                    const { set } = setWithNames;
195                    return (
196                      <SetView
197                        key={set.id}
198                        setWithNames={setWithNames}
199                        vlerkMode={vlerkMode}
200                        selectSet={() => selectSet(set)}
201                      />
202                    );
203                  })}
204                </Collapse>
205              </>
206            )}
207          </div>
208        </Collapse>
209      </>
210    )
211  );
212}
213
214function PhaseView({
215  phase,
216  initiallyOpen,
217  searchSubstr,
218  vlerkMode,
219  selectedBracketId,
220  getPhase,
221  getBracket,
222  selectSet,
223}: {
224  phase: Phase.AsObject;
225  initiallyOpen: boolean;
226  searchSubstr: string;
227  vlerkMode: boolean;
228  selectedBracketId: string | undefined;
229  getPhase: (id: string) => Promise<void>;
230  getBracket: (id: string) => Promise<void>;
231  selectSet: (set: Set, bracket: SelectedPhaseGroup) => Promise<void>;
232}) {
233  const [getting, setGetting] = useState(false);
234  const [open, setOpen] = useState(initiallyOpen);
235
236  const get = async () => {
237    setGetting(true);
238    await getPhase(phase.id);
239    setGetting(false);
240  };
241
242  return (
243    <>
244      <ListItemButton
245        dense
246        disableGutters
247        onClick={() => {
248          if (!open && phase.bracketsList.length === 0) {
249            get();
250          }
251          setOpen(!open);
252        }}
253        sx={{ typography: 'caption' }}
254      >
255        {open ? <KeyboardArrowDown /> : <KeyboardArrowRight />}
256        <Name>Phase ({phase.slug})</Name>
257        <Tooltip arrow title="Refresh phase">
258          <IconButton
259            onClick={(event) => {
260              event.stopPropagation();
261              get();
262            }}
263            size="small"
264          >
265            {getting ? <CircularProgress size="24px" /> : <Refresh />}
266          </IconButton>
267        </Tooltip>
268      </ListItemButton>
269      <Collapse in={open}>
270        <Block>
271          {phase.bracketsList.map((bracket) => (
272            <BracketView
273              key={bracket.id}
274              bracket={bracket}
275              initiallyOpen={
276                phase.bracketsList.length === 1 ||
277                bracket.id === selectedBracketId
278              }
279              searchSubstr={searchSubstr}
280              vlerkMode={vlerkMode}
281              getBracket={getBracket}
282              selectSet={(set: Set) =>
283                selectSet(set, {
284                  id: bracket.id,
285                  name: bracket.slug,
286                  hasSiblings: phase.bracketsList.length > 1,
287                  bracketType: bracket.type,
288                  waveId: null,
289                  winnersTargetPhaseId: null,
290                })
291              }
292            />
293          ))}
294        </Block>
295      </Collapse>
296    </>
297  );
298}
299
300function EventView({
301  event,
302  initiallyOpen,
303  searchSubstr,
304  vlerkMode,
305  selectedPhaseId,
306  selectedBracketId,
307  getEvent,
308  getPhase,
309  getBracket,
310  selectSet,
311}: {
312  event: Event.AsObject;
313  initiallyOpen: boolean;
314  searchSubstr: string;
315  vlerkMode: boolean;
316  selectedPhaseId: string | undefined;
317  selectedBracketId: string | undefined;
318  getEvent: (id: string) => Promise<void>;
319  getPhase: (id: string) => Promise<void>;
320  getBracket: (id: string) => Promise<void>;
321  selectSet: (
322    set: Set,
323    bracket: SelectedPhaseGroup,
324    phase: SelectedPhase,
325  ) => Promise<void>;
326}) {
327  const [getting, setGetting] = useState(false);
328  const [open, setOpen] = useState(initiallyOpen);
329
330  const get = async () => {
331    setGetting(true);
332    await getEvent(event.id);
333    setGetting(false);
334  };
335
336  return (
337    <>
338      <ListItemButton
339        dense
340        disableGutters
341        onClick={() => {
342          if (!open && event.phasesList.length === 0) {
343            get();
344          }
345          setOpen(!open);
346        }}
347        sx={{ typography: 'caption' }}
348      >
349        {open ? <KeyboardArrowDown /> : <KeyboardArrowRight />}
350        <Name>{event.name}</Name>
351        <Box>
352          <Tooltip arrow title="Refresh event">
353            <IconButton
354              onClick={(ev) => {
355                ev.stopPropagation();
356                get();
357              }}
358              size="small"
359            >
360              {getting ? <CircularProgress size="24px" /> : <Refresh />}
361            </IconButton>
362          </Tooltip>
363        </Box>
364      </ListItemButton>
365      <Collapse in={open}>
366        <Block>
367          {event.phasesList.map((phase) => (
368            <PhaseView
369              key={phase.id}
370              phase={phase}
371              initiallyOpen={
372                event.phasesList.length === 1 || phase.id === selectedPhaseId
373              }
374              searchSubstr={searchSubstr}
375              vlerkMode={vlerkMode}
376              selectedBracketId={selectedBracketId}
377              getPhase={getPhase}
378              getBracket={getBracket}
379              selectSet={(set: Set, bracket: SelectedPhaseGroup) =>
380                selectSet(set, bracket, {
381                  id: phase.id,
382                  name: phase.slug,
383                  hasSiblings: event.phasesList.length > 1,
384                })
385              }
386            />
387          ))}
388        </Block>
389      </Collapse>
390    </>
391  );
392}
393
394export default function ParryggView({
395  searchSubstr,
396  tournament,
397  vlerkMode,
398  selectedEventId,
399  selectedPhaseId,
400  selectedBracketId,
401  getEvent,
402  getPhase,
403  getBracket,
404  selectSet,
405}: {
406  searchSubstr: string;
407  tournament: Tournament.AsObject | undefined;
408  vlerkMode: boolean;
409  selectedEventId: string | undefined;
410  selectedPhaseId: string | undefined;
411  selectedBracketId: string | undefined;
412  getEvent: (id: string) => Promise<void>;
413  getPhase: (id: string) => Promise<void>;
414  getBracket: (id: string) => Promise<void>;
415  selectSet: (
416    set: Set,
417    bracket: SelectedPhaseGroup,
418    phase: SelectedPhase,
419    event: SelectedEvent,
420  ) => Promise<void>;
421}) {
422  const events = tournament?.eventsList || [];
423  return (
424    <Box bgcolor="white">
425      {events.map((event) => (
426        <EventView
427          key={event.id}
428          event={event}
429          initiallyOpen={events.length === 1 || event.id === selectedEventId}
430          searchSubstr={searchSubstr}
431          vlerkMode={vlerkMode}
432          selectedPhaseId={selectedPhaseId}
433          selectedBracketId={selectedBracketId}
434          getEvent={getEvent}
435          getPhase={getPhase}
436          getBracket={getBracket}
437          selectSet={(
438            set: Set,
439            bracket: SelectedPhaseGroup,
440            phase: SelectedPhase,
441          ) =>
442            selectSet(set, bracket, phase, {
443              id: event.id,
444              name: event.name,
445              slug: event.slug,
446              hasSiblings: events.length > 1,
447            })
448          }
449        />
450      ))}
451    </Box>
452  );
453}