fork/replay-manager-for-slippi

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

Nicoletfilter videogameId and not isOnline9351866

2.3.5
9.3 KiB353 linesraw
1import { Box, Collapse, ListItemButton, Typography } from '@mui/material';
2import { useMemo, useState } from 'react';
3import styled from '@emotion/styled';
4import {
5  KeyboardArrowDown,
6  KeyboardArrowRight,
7  KeyboardArrowUp,
8} from '@mui/icons-material';
9import {
10  NameWithHighlight,
11  RendererOfflineModeEvent,
12  RendererOfflineModePhase,
13  RendererOfflineModePool,
14  RendererOfflineModeTournament,
15  SelectedEvent,
16  SelectedPhase,
17  SelectedPhaseGroup,
18  Set,
19  State,
20} from '../common/types';
21import filterSets from './filterSets';
22import SetViewInner from './SetView';
23
24const Block = styled.div`
25  padding-left: 8px;
26`;
27
28const Name = styled.div`
29  overflow-x: hidden;
30  text-overflow: ellipsis;
31  white-space: nowrap;
32`;
33
34function SetView({
35  set,
36  entrant1Names,
37  entrant2Names,
38  vlerkMode,
39  selectSet,
40}: {
41  set: Set;
42  entrant1Names: NameWithHighlight[];
43  entrant2Names: NameWithHighlight[];
44  vlerkMode: boolean;
45  selectSet: () => Promise<void>;
46}) {
47  return (
48    <ListItemButton
49      dense
50      disableGutters
51      onClick={() => {
52        selectSet();
53      }}
54    >
55      <SetViewInner
56        entrant1Names={entrant1Names}
57        entrant1Score={set.entrant1Score}
58        entrant1Win={set.entrant1Id === set.winnerId}
59        entrant2Names={entrant2Names}
60        entrant2Score={set.entrant2Score}
61        fullRoundText={set.fullRoundText}
62        showScores={set.state === State.COMPLETED}
63        state={set.state}
64        stream={set.stream}
65        station={set.station}
66        wasReported={vlerkMode && set.wasReported}
67        updatedAtMs={set.updatedAtMs}
68      />
69    </ListItemButton>
70  );
71}
72
73function PoolView({
74  pool,
75  initiallyOpen,
76  ancestorsOpen,
77  searchSubstr,
78  vlerkMode,
79  selectSet,
80}: {
81  pool: RendererOfflineModePool;
82  initiallyOpen: boolean;
83  ancestorsOpen: boolean;
84  searchSubstr: string;
85  vlerkMode: boolean;
86  selectSet: (set: Set) => Promise<void>;
87}) {
88  const [completedOpen, setCompletedOpen] = useState(vlerkMode);
89  const [open, setOpen] = useState(initiallyOpen);
90
91  const pendingSetsToShow = useMemo(
92    () => filterSets(pool.sets.pendingSets, searchSubstr),
93    [pool, searchSubstr],
94  );
95  const completedSetsToShow = useMemo(
96    () => filterSets(pool.sets.completedSets, searchSubstr),
97    [pool, searchSubstr],
98  );
99
100  return (
101    (!searchSubstr ||
102      pendingSetsToShow.length > 0 ||
103      completedSetsToShow.length > 0) && (
104      <>
105        <ListItemButton
106          dense
107          disableGutters
108          sx={{ typography: 'caption' }}
109          onClick={() => {
110            setOpen((oldOpen) => !oldOpen);
111          }}
112        >
113          {open ? <KeyboardArrowDown /> : <KeyboardArrowRight />}
114          <Name>{pool.name}</Name>
115          {'\u00A0'}({pool.id})
116        </ListItemButton>
117        <Collapse in={open && ancestorsOpen} unmountOnExit>
118          <div style={{ marginLeft: '-16px' }}>
119            {pendingSetsToShow.map((setWithNames) => (
120              <SetView
121                key={setWithNames.set.id}
122                set={setWithNames.set}
123                entrant1Names={setWithNames.entrant1Names}
124                entrant2Names={setWithNames.entrant2Names}
125                vlerkMode={vlerkMode}
126                selectSet={() => selectSet(setWithNames.set)}
127              />
128            ))}
129            {completedSetsToShow.length > 0 && (
130              <>
131                <ListItemButton
132                  dense
133                  onClick={() =>
134                    setCompletedOpen((oldCompletedOpen) => !oldCompletedOpen)
135                  }
136                >
137                  <Typography
138                    alignItems="center"
139                    display="flex"
140                    justifyContent="right"
141                    variant="subtitle2"
142                    width="100%"
143                  >
144                    completed
145                    {completedOpen ? (
146                      <KeyboardArrowUp />
147                    ) : (
148                      <KeyboardArrowDown />
149                    )}
150                  </Typography>
151                </ListItemButton>
152                <Collapse in={completedOpen && ancestorsOpen} unmountOnExit>
153                  {completedSetsToShow.map((setWithNames) => (
154                    <SetView
155                      key={setWithNames.set.id}
156                      set={setWithNames.set}
157                      entrant1Names={setWithNames.entrant1Names}
158                      entrant2Names={setWithNames.entrant2Names}
159                      vlerkMode={vlerkMode}
160                      selectSet={() => selectSet(setWithNames.set)}
161                    />
162                  ))}
163                </Collapse>
164              </>
165            )}
166          </div>
167        </Collapse>
168      </>
169    )
170  );
171}
172
173function PhaseView({
174  phase,
175  initiallyOpen,
176  ancestorsOpen,
177  searchSubstr,
178  vlerkMode,
179  selectedPhaseGroupId,
180  selectSet,
181}: {
182  phase: RendererOfflineModePhase;
183  initiallyOpen: boolean;
184  ancestorsOpen: boolean;
185  searchSubstr: string;
186  vlerkMode: boolean;
187  selectedPhaseGroupId: number | undefined;
188  selectSet: (set: Set, phaseGroup: SelectedPhaseGroup) => Promise<void>;
189}) {
190  const [open, setOpen] = useState(initiallyOpen);
191
192  return (
193    <>
194      <ListItemButton
195        dense
196        disableGutters
197        sx={{ typography: 'caption' }}
198        onClick={() => {
199          setOpen((oldOpen) => !oldOpen);
200        }}
201      >
202        {open ? <KeyboardArrowDown /> : <KeyboardArrowRight />}
203        <Name>{phase.name}</Name>
204        {'\u00A0'}({phase.id})
205      </ListItemButton>
206      <Collapse in={open}>
207        <Block>
208          {phase.pools.map((pool) => (
209            <PoolView
210              key={pool.id}
211              pool={pool}
212              initiallyOpen={
213                phase.pools.length === 1 || pool.id === selectedPhaseGroupId
214              }
215              ancestorsOpen={ancestorsOpen && open}
216              searchSubstr={searchSubstr}
217              vlerkMode={vlerkMode}
218              selectSet={(set: Set) =>
219                selectSet(set, {
220                  id: pool.id,
221                  name: pool.name,
222                  bracketType: pool.bracketType,
223                  hasSiblings: phase.pools.length > 1,
224                  waveId: pool.waveId,
225                  winnersTargetPhaseId: pool.winnersTargetPhaseId,
226                })
227              }
228            />
229          ))}
230        </Block>
231      </Collapse>
232    </>
233  );
234}
235
236function EventView({
237  event,
238  initiallyOpen,
239  searchSubstr,
240  vlerkMode,
241  selectedPhaseId,
242  selectedPhaseGroupId,
243  selectSet,
244}: {
245  event: RendererOfflineModeEvent;
246  initiallyOpen: boolean;
247  searchSubstr: string;
248  vlerkMode: boolean;
249  selectedPhaseId: number | undefined;
250  selectedPhaseGroupId: number | undefined;
251  selectSet: (
252    set: Set,
253    phaseGroup: SelectedPhaseGroup,
254    phase: SelectedPhase,
255  ) => Promise<void>;
256}) {
257  const [open, setOpen] = useState(initiallyOpen);
258
259  return (
260    <>
261      <ListItemButton
262        dense
263        disableGutters
264        onClick={() => {
265          setOpen((oldOpen) => !oldOpen);
266        }}
267        sx={{ typography: 'caption' }}
268      >
269        {open ? <KeyboardArrowDown /> : <KeyboardArrowRight />}
270        <Name>{event.name}</Name>
271        {'\u00A0'}({event.id})
272      </ListItemButton>
273      <Collapse in={open}>
274        <Block>
275          {event.phases.map((phase) => (
276            <PhaseView
277              key={phase.id}
278              phase={phase}
279              initiallyOpen={
280                event.phases.length === 1 || phase.id === selectedPhaseId
281              }
282              ancestorsOpen={open}
283              searchSubstr={searchSubstr}
284              vlerkMode={vlerkMode}
285              selectedPhaseGroupId={selectedPhaseGroupId}
286              selectSet={(set: Set, phaseGroup: SelectedPhaseGroup) =>
287                selectSet(set, phaseGroup, {
288                  id: phase.id,
289                  name: phase.name,
290                  hasSiblings: event.phases.length > 1,
291                })
292              }
293            />
294          ))}
295        </Block>
296      </Collapse>
297    </>
298  );
299}
300
301export default function OfflineModeView({
302  searchSubstr,
303  offlineModeTournament,
304  vlerkMode,
305  selectedEventId,
306  selectedPhaseId,
307  selectedPhaseGroupId,
308  selectSet,
309}: {
310  searchSubstr: string;
311  offlineModeTournament: RendererOfflineModeTournament;
312  vlerkMode: boolean;
313  selectedEventId: number | undefined;
314  selectedPhaseId: number | undefined;
315  selectedPhaseGroupId: number | undefined;
316  selectSet: (
317    set: Set,
318    phaseGroup: SelectedPhaseGroup,
319    phase: SelectedPhase,
320    event: SelectedEvent,
321  ) => Promise<void>;
322}) {
323  return (
324    <Box bgcolor="white">
325      {offlineModeTournament.events.map((event) => (
326        <EventView
327          key={event.id}
328          event={event}
329          initiallyOpen={
330            offlineModeTournament.events.length === 1 ||
331            event.id === selectedEventId
332          }
333          searchSubstr={searchSubstr}
334          vlerkMode={vlerkMode}
335          selectedPhaseId={selectedPhaseId}
336          selectedPhaseGroupId={selectedPhaseGroupId}
337          selectSet={(
338            set: Set,
339            phaseGroup: SelectedPhaseGroup,
340            phase: SelectedPhase,
341          ) =>
342            selectSet(set, phaseGroup, phase, {
343              id: event.id,
344              name: event.name,
345              slug: event.slug,
346              hasSiblings: offlineModeTournament.events.length > 1,
347            })
348          }
349        />
350      ))}
351    </Box>
352  );
353}