Compare commits

...
22 Commits
Author SHA1 Message Date
dahyeon bb336391ff docs: make readme demo loop 2026-06-09 06:28:15 -07:00
dahyeon 3f4ddead72 docs: update release readme media 2026-06-09 06:25:41 -07:00
dahyeon 168e0eca66 docs: refresh readme for release 77 2026-06-09 06:17:45 -07:00
dahyeon e7eaa4f67d fix(web): stack mobile tier badges 2026-06-09 04:51:37 -07:00
dahyeon ad9bf93b52 fix(web): increase light mode text contrast 2026-06-09 04:48:18 -07:00
dahyeon 774707de65 fix(web): enlarge desktop position text 2026-06-09 04:03:00 -07:00
dahyeon e28a2646bf fix(web): add slight tier badge spacing 2026-06-09 04:01:37 -07:00
dahyeon 2916333d71 fix(web): align tier queue columns 2026-06-09 03:59:53 -07:00
dahyeon d3d5f2b348 fix(web): prevent logout button overflow 2026-06-09 03:54:11 -07:00
dahyeon 4657cd453c fix(web): scale match participant icons with text 2026-06-09 03:38:13 -07:00
dahyeon 577ce45b64 fix(web): align header and match badges with brand styling 2026-06-09 03:37:11 -07:00
dahyeon ee3e5935d6 fix(web): stabilize recruiting mobile participant list 2026-06-09 03:17:49 -07:00
dahyeon 5ba68ea134 fix(web): improve compact UI readability 2026-06-09 03:12:00 -07:00
dahyeon 12869a7e9e fix(web): stabilize participant filter table 2026-06-08 23:10:39 -07:00
dahyeon d10e2ab011 fix(web): keep history table shell during loading 2026-06-08 22:48:16 -07:00
dahyeon 170e42098a fix(web): stabilize history table columns 2026-06-08 22:32:22 -07:00
dahyeon fe7a482969 fix(web): localize history pagination loading 2026-06-08 22:24:20 -07:00
dahyeon aa07ec0304 feat(api): add dakao schedule links 2026-06-08 21:44:28 -07:00
dahyeon cd5a82aa93 fix(web): refine mobile history cards 2026-06-08 05:39:22 -07:00
dahyeon 7a62e52d60 fix(web): improve mobile team layout 2026-06-08 05:24:14 -07:00
dahyeon 6fc58fec1d feat(web): add legal footer 2026-06-08 04:50:29 -07:00
dahyeon f586542dc3 fix(web): split home matches by schedule 2026-06-08 04:44:12 -07:00
41 changed files with 2796 additions and 569 deletions

No files matched your search

+1 -1
View File
@@ -1 +1 @@
68 77
+480
View File
@@ -0,0 +1,480 @@
GNU LIBRARY GENERAL PUBLIC LICENSE
Version 2, June 1991
Copyright (C) 1991 Free Software Foundation, Inc.
<https://fsf.org/>
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
[This is the first released version of the library GPL. It is
numbered 2 because it goes with version 2 of the ordinary GPL.]
Preamble
The licenses for most software are designed to take away your
freedom to share and change it. By contrast, the GNU General Public
Licenses are intended to guarantee your freedom to share and change
free software--to make sure the software is free for all its users.
This license, the Library General Public License, applies to some
specially designated Free Software Foundation software, and to any
other libraries whose authors decide to use it. You can use it for
your libraries, too.
When we speak of free software, we are referring to freedom, not
price. Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
this service if you wish), that you receive source code or can get it
if you want it, that you can change the software or use pieces of it
in new free programs; and that you know you can do these things.
To protect your rights, we need to make restrictions that forbid
anyone to deny you these rights or to ask you to surrender the rights.
These restrictions translate to certain responsibilities for you if
you distribute copies of the library, or if you modify it.
For example, if you distribute copies of the library, whether gratis
or for a fee, you must give the recipients all the rights that we gave
you. You must make sure that they, too, receive or can get the source
code. If you link a program with the library, you must provide
complete object files to the recipients so that they can relink them
with the library, after making changes to the library and recompiling
it. And you must show them these terms so they know their rights.
Our method of protecting your rights has two steps: (1) copyright
the library, and (2) offer you this license which gives you legal
permission to copy, distribute and/or modify the library.
Also, for each distributor's protection, we want to make certain
that everyone understands that there is no warranty for this free
library. If the library is modified by someone else and passed on, we
want its recipients to know that what they have is not the original
version, so that any problems introduced by others will not reflect on
the original authors' reputations.
Finally, any free program is threatened constantly by software
patents. We wish to avoid the danger that companies distributing free
software will individually obtain patent licenses, thus in effect
transforming the program into proprietary software. To prevent this,
we have made it clear that any patent must be licensed for everyone's
free use or not licensed at all.
Most GNU software, including some libraries, is covered by the ordinary
GNU General Public License, which was designed for utility programs. This
license, the GNU Library General Public License, applies to certain
designated libraries. This license is quite different from the ordinary
one; be sure to read it in full, and don't assume that anything in it is
the same as in the ordinary license.
The reason we have a separate public license for some libraries is that
they blur the distinction we usually make between modifying or adding to a
program and simply using it. Linking a program with a library, without
changing the library, is in some sense simply using the library, and is
analogous to running a utility program or application program. However, in
a textual and legal sense, the linked executable is a combined work, a
derivative of the original library, and the ordinary General Public License
treats it as such.
Because of this blurred distinction, using the ordinary General
Public License for libraries did not effectively promote software
sharing, because most developers did not use the libraries. We
concluded that weaker conditions might promote sharing better.
However, unrestricted linking of non-free programs would deprive the
users of those programs of all benefit from the free status of the
libraries themselves. This Library General Public License is intended to
permit developers of non-free programs to use free libraries, while
preserving your freedom as a user of such programs to change the free
libraries that are incorporated in them. (We have not seen how to achieve
this as regards changes in header files, but we have achieved it as regards
changes in the actual functions of the Library.) The hope is that this
will lead to faster development of free libraries.
The precise terms and conditions for copying, distribution and
modification follow. Pay close attention to the difference between a
"work based on the library" and a "work that uses the library". The
former contains code derived from the library, while the latter only
works together with the library.
Note that it is possible for a library to be covered by the ordinary
General Public License rather than by this special one.
GNU LIBRARY GENERAL PUBLIC LICENSE
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
0. This License Agreement applies to any software library which
contains a notice placed by the copyright holder or other authorized
party saying it may be distributed under the terms of this Library
General Public License (also called "this License"). Each licensee is
addressed as "you".
A "library" means a collection of software functions and/or data
prepared so as to be conveniently linked with application programs
(which use some of those functions and data) to form executables.
The "Library", below, refers to any such software library or work
which has been distributed under these terms. A "work based on the
Library" means either the Library or any derivative work under
copyright law: that is to say, a work containing the Library or a
portion of it, either verbatim or with modifications and/or translated
straightforwardly into another language. (Hereinafter, translation is
included without limitation in the term "modification".)
"Source code" for a work means the preferred form of the work for
making modifications to it. For a library, complete source code means
all the source code for all modules it contains, plus any associated
interface definition files, plus the scripts used to control compilation
and installation of the library.
Activities other than copying, distribution and modification are not
covered by this License; they are outside its scope. The act of
running a program using the Library is not restricted, and output from
such a program is covered only if its contents constitute a work based
on the Library (independent of the use of the Library in a tool for
writing it). Whether that is true depends on what the Library does
and what the program that uses the Library does.
1. You may copy and distribute verbatim copies of the Library's
complete source code as you receive it, in any medium, provided that
you conspicuously and appropriately publish on each copy an
appropriate copyright notice and disclaimer of warranty; keep intact
all the notices that refer to this License and to the absence of any
warranty; and distribute a copy of this License along with the
Library.
You may charge a fee for the physical act of transferring a copy,
and you may at your option offer warranty protection in exchange for a
fee.
2. You may modify your copy or copies of the Library or any portion
of it, thus forming a work based on the Library, and copy and
distribute such modifications or work under the terms of Section 1
above, provided that you also meet all of these conditions:
a) The modified work must itself be a software library.
b) You must cause the files modified to carry prominent notices
stating that you changed the files and the date of any change.
c) You must cause the whole of the work to be licensed at no
charge to all third parties under the terms of this License.
d) If a facility in the modified Library refers to a function or a
table of data to be supplied by an application program that uses
the facility, other than as an argument passed when the facility
is invoked, then you must make a good faith effort to ensure that,
in the event an application does not supply such function or
table, the facility still operates, and performs whatever part of
its purpose remains meaningful.
(For example, a function in a library to compute square roots has
a purpose that is entirely well-defined independent of the
application. Therefore, Subsection 2d requires that any
application-supplied function or table used by this function must
be optional: if the application does not supply it, the square
root function must still compute square roots.)
These requirements apply to the modified work as a whole. If
identifiable sections of that work are not derived from the Library,
and can be reasonably considered independent and separate works in
themselves, then this License, and its terms, do not apply to those
sections when you distribute them as separate works. But when you
distribute the same sections as part of a whole which is a work based
on the Library, the distribution of the whole must be on the terms of
this License, whose permissions for other licensees extend to the
entire whole, and thus to each and every part regardless of who wrote
it.
Thus, it is not the intent of this section to claim rights or contest
your rights to work written entirely by you; rather, the intent is to
exercise the right to control the distribution of derivative or
collective works based on the Library.
In addition, mere aggregation of another work not based on the Library
with the Library (or with a work based on the Library) on a volume of
a storage or distribution medium does not bring the other work under
the scope of this License.
3. You may opt to apply the terms of the ordinary GNU General Public
License instead of this License to a given copy of the Library. To do
this, you must alter all the notices that refer to this License, so
that they refer to the ordinary GNU General Public License, version 2,
instead of to this License. (If a newer version than version 2 of the
ordinary GNU General Public License has appeared, then you can specify
that version instead if you wish.) Do not make any other change in
these notices.
Once this change is made in a given copy, it is irreversible for
that copy, so the ordinary GNU General Public License applies to all
subsequent copies and derivative works made from that copy.
This option is useful when you wish to copy part of the code of
the Library into a program that is not a library.
4. You may copy and distribute the Library (or a portion or
derivative of it, under Section 2) in object code or executable form
under the terms of Sections 1 and 2 above provided that you accompany
it with the complete corresponding machine-readable source code, which
must be distributed under the terms of Sections 1 and 2 above on a
medium customarily used for software interchange.
If distribution of object code is made by offering access to copy
from a designated place, then offering equivalent access to copy the
source code from the same place satisfies the requirement to
distribute the source code, even though third parties are not
compelled to copy the source along with the object code.
5. A program that contains no derivative of any portion of the
Library, but is designed to work with the Library by being compiled or
linked with it, is called a "work that uses the Library". Such a
work, in isolation, is not a derivative work of the Library, and
therefore falls outside the scope of this License.
However, linking a "work that uses the Library" with the Library
creates an executable that is a derivative of the Library (because it
contains portions of the Library), rather than a "work that uses the
library". The executable is therefore covered by this License.
Section 6 states terms for distribution of such executables.
When a "work that uses the Library" uses material from a header file
that is part of the Library, the object code for the work may be a
derivative work of the Library even though the source code is not.
Whether this is true is especially significant if the work can be
linked without the Library, or if the work is itself a library. The
threshold for this to be true is not precisely defined by law.
If such an object file uses only numerical parameters, data
structure layouts and accessors, and small macros and small inline
functions (ten lines or less in length), then the use of the object
file is unrestricted, regardless of whether it is legally a derivative
work. (Executables containing this object code plus portions of the
Library will still fall under Section 6.)
Otherwise, if the work is a derivative of the Library, you may
distribute the object code for the work under the terms of Section 6.
Any executables containing that work also fall under Section 6,
whether or not they are linked directly with the Library itself.
6. As an exception to the Sections above, you may also compile or
link a "work that uses the Library" with the Library to produce a
work containing portions of the Library, and distribute that work
under terms of your choice, provided that the terms permit
modification of the work for the customer's own use and reverse
engineering for debugging such modifications.
You must give prominent notice with each copy of the work that the
Library is used in it and that the Library and its use are covered by
this License. You must supply a copy of this License. If the work
during execution displays copyright notices, you must include the
copyright notice for the Library among them, as well as a reference
directing the user to the copy of this License. Also, you must do one
of these things:
a) Accompany the work with the complete corresponding
machine-readable source code for the Library including whatever
changes were used in the work (which must be distributed under
Sections 1 and 2 above); and, if the work is an executable linked
with the Library, with the complete machine-readable "work that
uses the Library", as object code and/or source code, so that the
user can modify the Library and then relink to produce a modified
executable containing the modified Library. (It is understood
that the user who changes the contents of definitions files in the
Library will not necessarily be able to recompile the application
to use the modified definitions.)
b) Accompany the work with a written offer, valid for at
least three years, to give the same user the materials
specified in Subsection 6a, above, for a charge no more
than the cost of performing this distribution.
c) If distribution of the work is made by offering access to copy
from a designated place, offer equivalent access to copy the above
specified materials from the same place.
d) Verify that the user has already received a copy of these
materials or that you have already sent this user a copy.
For an executable, the required form of the "work that uses the
Library" must include any data and utility programs needed for
reproducing the executable from it. However, as a special exception,
the source code distributed need not include anything that is normally
distributed (in either source or binary form) with the major
components (compiler, kernel, and so on) of the operating system on
which the executable runs, unless that component itself accompanies
the executable.
It may happen that this requirement contradicts the license
restrictions of other proprietary libraries that do not normally
accompany the operating system. Such a contradiction means you cannot
use both them and the Library together in an executable that you
distribute.
7. You may place library facilities that are a work based on the
Library side-by-side in a single library together with other library
facilities not covered by this License, and distribute such a combined
library, provided that the separate distribution of the work based on
the Library and of the other library facilities is otherwise
permitted, and provided that you do these two things:
a) Accompany the combined library with a copy of the same work
based on the Library, uncombined with any other library
facilities. This must be distributed under the terms of the
Sections above.
b) Give prominent notice with the combined library of the fact
that part of it is a work based on the Library, and explaining
where to find the accompanying uncombined form of the same work.
8. You may not copy, modify, sublicense, link with, or distribute
the Library except as expressly provided under this License. Any
attempt otherwise to copy, modify, sublicense, link with, or
distribute the Library is void, and will automatically terminate your
rights under this License. However, parties who have received copies,
or rights, from you under this License will not have their licenses
terminated so long as such parties remain in full compliance.
9. You are not required to accept this License, since you have not
signed it. However, nothing else grants you permission to modify or
distribute the Library or its derivative works. These actions are
prohibited by law if you do not accept this License. Therefore, by
modifying or distributing the Library (or any work based on the
Library), you indicate your acceptance of this License to do so, and
all its terms and conditions for copying, distributing or modifying
the Library or works based on it.
10. Each time you redistribute the Library (or any work based on the
Library), the recipient automatically receives a license from the
original licensor to copy, distribute, link with or modify the Library
subject to these terms and conditions. You may not impose any further
restrictions on the recipients' exercise of the rights granted herein.
You are not responsible for enforcing compliance by third parties to
this License.
11. If, as a consequence of a court judgment or allegation of patent
infringement or for any other reason (not limited to patent issues),
conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License. If you cannot
distribute so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you
may not distribute the Library at all. For example, if a patent
license would not permit royalty-free redistribution of the Library by
all those who receive copies directly or indirectly through you, then
the only way you could satisfy both it and this License would be to
refrain entirely from distribution of the Library.
If any portion of this section is held invalid or unenforceable under any
particular circumstance, the balance of the section is intended to apply,
and the section as a whole is intended to apply in other circumstances.
It is not the purpose of this section to induce you to infringe any
patents or other property right claims or to contest validity of any
such claims; this section has the sole purpose of protecting the
integrity of the free software distribution system which is
implemented by public license practices. Many people have made
generous contributions to the wide range of software distributed
through that system in reliance on consistent application of that
system; it is up to the author/donor to decide if he or she is willing
to distribute software through any other system and a licensee cannot
impose that choice.
This section is intended to make thoroughly clear what is believed to
be a consequence of the rest of this License.
12. If the distribution and/or use of the Library is restricted in
certain countries either by patents or by copyrighted interfaces, the
original copyright holder who places the Library under this License may add
an explicit geographical distribution limitation excluding those countries,
so that distribution is permitted only in or among countries not thus
excluded. In such case, this License incorporates the limitation as if
written in the body of this License.
13. The Free Software Foundation may publish revised and/or new
versions of the Library General Public License from time to time.
Such new versions will be similar in spirit to the present version,
but may differ in detail to address new problems or concerns.
Each version is given a distinguishing version number. If the Library
specifies a version number of this License which applies to it and
"any later version", you have the option of following the terms and
conditions either of that version or of any later version published by
the Free Software Foundation. If the Library does not specify a
license version number, you may choose any version ever published by
the Free Software Foundation.
14. If you wish to incorporate parts of the Library into other free
programs whose distribution conditions are incompatible with these,
write to the author to ask for permission. For software which is
copyrighted by the Free Software Foundation, write to the Free
Software Foundation; we sometimes make exceptions for this. Our
decision will be guided by the two goals of preserving the free status
of all derivatives of our free software and of promoting the sharing
and reuse of software generally.
NO WARRANTY
15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
DAMAGES.
END OF TERMS AND CONDITIONS
How to Apply These Terms to Your New Libraries
If you develop a new library, and you want it to be of the greatest
possible use to the public, we recommend making it free software that
everyone can redistribute and change. You can do so by permitting
redistribution under these terms (or, alternatively, under the terms of the
ordinary General Public License).
To apply these terms, attach the following notices to the library. It is
safest to attach them to the start of each source file to most effectively
convey the exclusion of warranty; and each file should have at least the
"copyright" line and a pointer to where the full notice is found.
<one line to give the library's name and a brief idea of what it does.>
Copyright (C) <year> <name of author>
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with this library; if not, see <https://www.gnu.org/licenses/>.
Also add information on how to contact you by electronic and paper mail.
You should also get your employer (if you work as a programmer) or your
school, if any, to sign a "copyright disclaimer" for the library, if
necessary. Here is a sample; alter the names:
Yoyodyne, Inc., hereby disclaims all copyright interest in the
library `Frob' (a library for tweaking knobs) written by James Random Hacker.
<signature of Moe Ghoul>, 1 April 1990
Moe Ghoul, President of Vice
That's all there is to it!
+90 -61
View File
@@ -1,56 +1,89 @@
# LOLYMPUS # LOLYMPUS
![LOLYMPUS match list](docs/screenshots/lolympus-match-list.png) LOLYMPUS는 리그 오브 레전드 커뮤니티의 여러 이벤트 중 내전(사용자 설정 게임)을 운영할 때 필요한 일정 관리, 참여자 모집, 팀 빌딩, 토너먼트 코드 배정, 경기 진행, 실시간 라이브 방송(추후 지원 예정), 결과 수집, 전적 확인을 한곳에서 처리하기 위한 웹 애플리케이션입니다.
## Overview <p align="center">
<video
src="https://git.dahyeon.us/dahyeon/lolympus-tournament-support/raw/branch/release/77/docs/screenshots/lolympus-demo.mp4"
poster="docs/screenshots/lolympus-auction.png"
width="960"
autoplay="autoplay"
muted="muted"
loop="loop"
playsinline="playsinline"
controls
>
<a href="https://git.dahyeon.us/dahyeon/lolympus-tournament-support/raw/branch/release/77/docs/screenshots/lolympus-demo.mp4">3초 간격 데모 영상 보기</a>
</video>
</p>
LOLYMPUS는 리그 오브 레전드 내전을 운영할 때 필요한 것들을 한곳에 모아둔 웹 애플리케이션입니다. <p align="center">
<a href="https://git.dahyeon.us/dahyeon/lolympus-tournament-support/raw/branch/release/77/docs/screenshots/lolympus-demo.mp4">3초 간격 데모 영상 보기</a>
</p>
참가자 모집, 팀 편성, 경매, 토너먼트 코드 배정, 경기 결과 수집, 전적 확인처럼 운영자가 매번 손으로 챙기던 일을 줄이는 데 초점을 맞췄습니다. 처음부터 큰 서비스로 만들었다기보다는, 실제 커뮤니티 내전을 굴리면서 불편했던 부분을 하나씩 붙여가며 만든 프로젝트입니다. ## 배포 주소
## Purpose | Environment | Version | URL |
| ----------- | ------- | -------------------------------------- |
| Production | v77 | <https://lolympus.dahyeon.us/> |
| Staging | v77 | <https://890c50be.lolympus.pages.dev/> |
내전은 사람만 모이면 끝나는 일이 아니었습니다. 참가자 티어를 확인하고, 포지션을 맞추고, 팀장을 정하고, 경기마다 토너먼트 코드를 나눠주고, 끝난 뒤 결과까지 정리해야 했습니다. ## 개요
이 프로젝트는 그 흐름을 최대한 덜 번거롭게 만들기 위해 시작했습니다. 운영자는 전체 진행 상황을 보고, 참가자는 본인이 속한 팀과 다음 경기를 빠르게 확인할 수 있도록 구성했습니다. 내전 운영은 사람을 모으는 것에서 끝나지 않습니다. 참가자의 티어와 포지션을 확인하고, 팀장을 정하고, 팀을 나누고, 경기마다 토너먼트 코드를 전달하고, 끝난 뒤 결과와 전적까지 정리해야 합니다.
## Screens LOLYMPUS는 이 반복 작업을 줄이는 데 초점을 맞췄습니다. 운영자는 전체 진행 상황을 한눈에 보고, 참가자는 카카오톡 연동을 통해 쉽게 일정 확인/참가 신청하고 본인이 속한 팀과 다음 경기 정보를 빠르게 확인할 수 있습니다.
### Match detail ## 워크플로우
![LOLYMPUS match detail](docs/screenshots/lolympus-match-detail.png) 1. **내전 개설과 모집**
내전 일정, 진행 방식, 정원, 공지사항을 등록하고 참가 신청 현황을 확인합니다.
### Team progress 2. **참가자 정보 확인**
Riot 계정 기반으로 소환사명, 태그, 프로필 아이콘, 솔로랭크/자유랭크 티어, 선호 포지션을 보여줍니다.
![LOLYMPUS team progress](docs/screenshots/lolympus-team-progress.png) 3. **팀 빌딩과 경매**
팀장을 기준으로 팀을 구성하거나, 경매 방식으로 참가자를 배정합니다. 현재 입찰가, 팀별 포인트, 낙찰 기록을 함께 관리합니다.
## Functionalities 4. **팀별 진행 페이지**
각 팀은 예정 경기, 상대 팀, 라인업, 토너먼트 코드를 한 화면에서 확인하고 복사할 수 있습니다.
**1. 내전 관리** 5. **결과 수집과 통계**
내전 생성, 수정, 모집 상태 변경, 참가자 목록 확인을 할 수 있습니다. Riot Match-V5 데이터를 이용해 경기 결과를 수집하고, 소환사별 전적과 커뮤니티 리더보드를 제공합니다.
**2. 참가자 정보 관리** ## 스크린샷
Riot 계정 정보를 기반으로 소환사명, 태그, 프로필 아이콘, 솔로랭크/자유랭크 티어, 선호 포지션을 보여줍니다.
**3. 팀 빌딩** 상단의 경매 화면은 LOLYMPUS가 단순 참가자 목록을 넘어서 실제 팀빌딩 운영까지 다루는 대표 화면입니다. 3초 간격 데모 영상은 README 렌더러가 video 태그를 지원하면 자동/반복 재생되고, 세부 화면은 아래 PNG 원본을 기준으로 볼 수 있습니다.
팀장을 정하고 포지션을 맞춰 팀을 구성합니다. 여러 팀이 참여하는 내전도 처리할 수 있습니다.
**4. 경매 진행** | 경매 팀빌딩 |
팀장 경매 방식으로 참가자를 뽑을 수 있고, 현재 입찰가와 낙찰 기록을 관리합니다. | ----------------------------------------------------------------------------------------------------------------------------------------- |
| <a href="docs/screenshots/lolympus-demo.mp4"><img src="docs/screenshots/lolympus-auction.png" alt="LOLYMPUS 경매 팀빌딩" width="840"></a> |
**5. 토너먼트 코드 관리** | 내전 목록 | 모집 상세 |
업로드한 토너먼트 코드를 경기별로 배정하고, 팀별 진행 페이지에서 바로 복사할 수 있게 했습니다. | ----------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------- |
| <img src="docs/screenshots/lolympus-match-list.png" alt="LOLYMPUS 내전 목록" width="420"> | <img src="docs/screenshots/lolympus-match-recruiting.png" alt="LOLYMPUS 모집 상세" width="420"> |
**6. 팀별 진행 페이지** | 단판 경기 결과 | 개인 전적 |
각 팀이 자기 경기 일정, 상대 팀, 토너먼트 코드, 종료된 경기 결과를 한 화면에서 확인할 수 있습니다. | ------------------------------------------------------------------------------------------------------ | --------------------------------------------------------------------------------------------- |
| <img src="docs/screenshots/lolympus-match-result(pair).png" alt="LOLYMPUS 단판 경기 결과" width="420"> | <img src="docs/screenshots/lolympus-player-stats.png" alt="LOLYMPUS 소환사 전적" width="420"> |
**7. 전적 수집과 통계** | 경기 상세 |
Riot Match-V5 데이터를 이용해 내전 결과를 수집하고, 개인 전적과 커뮤니티 리더보드를 보여줍니다. | ------------------------------------------------------------------------------------------- |
| <img src="docs/screenshots/lolympus-match-detail.png" alt="LOLYMPUS 경기 상세" width="840"> |
**8. 커뮤니티 명령 연동** ## 기능
Dakao/NATS 기반 명령을 받아 참가 신청이나 운영 흐름과 연결할 수 있도록 구성했습니다.
## Used technologies - 내전 생성, 수정, 모집 상태 변경, 참가자 목록 확인
- 카카오톡 명령어를 통한 일정 조회, 내전 참가, 취소, 계정 등록 등 기능 제공
- Riot 계정 기반 참가자 프로필, 티어, 포지션 확인
- 팀장 지정, 포지션 기반 팀 구성, 다팀 내전 지원
- 팀장 경매 방식의 참가자 낙찰과 입찰 기록 관리
- 경기별 토너먼트 코드 배정과 팀별 복사 UI
- 팀별 경기 일정, 상대 팀, 라인업, 결과 확인
- Riot Match-V5 기반 결과 수집, 개인 전적, 리더보드 제공
- Dakao/NATS 기반 커뮤니티 명령 연동
## 기술 스택
- React - React
- Vite - Vite
@@ -62,53 +95,49 @@ Dakao/NATS 기반 명령을 받아 참가 신청이나 운영 흐름과 연결
- NATS - NATS
- Riot API - Riot API
- pnpm workspace - pnpm workspace
- Kubernetes
- ArgoCD
## Project structure ## 디렉터리 구조
```text ```text
apps/ apps/
api/ NestJS API server api/ NestJS API server
web/ React + Vite client web/ React + Vite client
scripts/ deployment and maintenance scripts docs/
screenshots/ README and project screenshots
scripts/ deployment and maintenance scripts
``` ```
## How to run ## 사전 요구사항
- Node.js 24 이상
- pnpm 10.4.1 (`packageManager` 기준, `corepack enable`로 활성화 권장)
- MongoDB 7.0, Redis 5.0 이상, NATS 실행 환경
## 실행 방법
```bash ```bash
pnpm install pnpm install
pnpm start:api:dev pnpm start:api:dev
pnpm dev:web pnpm start:web:dev
``` ```
웹 앱은 기본적으로 `apps/web/.env.development` 값을 사용합니다. API 환경값은 `apps/project.env`와 실행 환경의 시크릿 설정을 같이 확인합니다. 웹 앱은 기본적으로 `apps/web/.env.development` 값을 사용합니다. API 환경값은 `apps/project.env`와 실행 환경의 시크릿 설정을 함께 확인합니다.
## Checks 카카오톡 기반 명령어 기능은 Dakao(커스텀 카카오톡 게이트웨이) 연동이 필요합니다. Dakao가 실행 중이 아니거나 NATS를 통해 API 서버와 연결되어 있지 않으면 일정 조회, 내전 참가, 참가 취소, 계정 등록 같은 카카오톡 명령어는 사용할 수 없습니다.
```bash ## 커맨드
pnpm --filter api test
pnpm --filter web build:staging
```
현재 정리된 기준으로 API 테스트와 웹 테스트 빌드를 통과합니다. | Command | Description |
| --------------------------------- | -------------------------------- |
| `pnpm start:web:dev` | 웹 앱 개발 서버 실행 |
| `pnpm start:api:dev` | API 서버 dev 환경 실행 |
| `pnpm --filter api test` | API 테스트 실행 |
| `pnpm --filter web build:staging` | 웹 staging 빌드 검증 |
| `pnpm deploy:web:staging` | Cloudflare Pages staging 배포 |
| `pnpm deploy:web:prod` | Cloudflare Pages production 배포 |
## Deployment branches ## 라이선스
`main`은 항상 배포 가능한 trunk로 유지하고 dev 배포 기준으로 사용합니다. This project is licensed under the GNU Library General Public License v2.0. See [LICENSE](LICENSE) for details.
빌드 번호는 `BUILD_NUMBER` 파일에서 1씩 증가시키며, 현재 시작 번호는 `66`입니다.
staging 검증이 필요할 때는 `release/66` 같은 임시 브랜치를 만들고,
검증이 끝나면 삭제합니다.
```bash
git push origin main:release/66
pnpm deploy:web:staging
```
staging/prod Pages 배포 스크립트는 명시 릴리즈 브랜치 환경변수가 있으면 그
값을 사용하고, 없으면 최신 `release/*` 브랜치를 자동으로 선택합니다. 최신
기준은 브랜치가 가리키는 커밋 시각이며, 동률이면 브랜치명 내림차순입니다.
staging은 선택된 릴리즈 브랜치로 preview 배포를 만들고, prod는 Cloudflare
Pages production branch로 업로드해 production 배포를 만듭니다.
명시 릴리즈 브랜치는 staging은 `CF_PAGES_STAGING_BRANCH`, prod는
`CF_PAGES_RELEASE_BRANCH`로 지정합니다. Cloudflare Pages production branch가
`main`이 아니면 `CF_PAGES_PRODUCTION_BRANCH`로 지정합니다.
@@ -0,0 +1,148 @@
import { SecretService } from '../global/secret/secret.service';
import { DakaoUrlShortenerService } from './dakao-url-shortener.service';
describe('DakaoUrlShortenerService', () => {
const originalEnv = process.env;
const originalFetch = global.fetch;
beforeEach(() => {
process.env = { ...originalEnv };
});
afterEach(() => {
process.env = originalEnv;
global.fetch = originalFetch;
jest.restoreAllMocks();
});
function makeService(token = 'shortener-token') {
const secretService = {
get: jest.fn().mockResolvedValue(token),
} as unknown as jest.Mocked<SecretService>;
return {
service: new DakaoUrlShortenerService(secretService),
secretService,
};
}
it('posts a production match detail URL with a deterministic slug', async () => {
process.env.NODE_ENV = 'prod';
global.fetch = jest.fn().mockResolvedValue({
ok: true,
status: 201,
json: jest
.fn()
.mockResolvedValue({ shortUrl: 'https://go.dahyeon.us/lmtpAB12' }),
} as unknown as Response);
const { service } = makeService();
const shortUrl = await service.shortenMatchLink({
matchId: '333333333333333333333333',
shortCode: 'ab12',
});
expect(shortUrl).toBe('https://go.dahyeon.us/lmtpAB12');
expect(global.fetch).toHaveBeenCalledWith(
'https://go.dahyeon.us/api/shorten',
expect.objectContaining({
method: 'POST',
headers: expect.objectContaining({
Accept: 'application/json',
Authorization: 'Bearer shortener-token',
'Content-Type': 'application/json',
}),
}),
);
const init = (global.fetch as jest.Mock).mock.calls[0][1] as RequestInit;
expect(JSON.parse(init.body as string)).toEqual({
slug: 'lmtpAB12',
url: 'https://lolympus.dahyeon.us/match/333333333333333333333333',
redirectStatus: 302,
expiresAt: null,
});
});
it('uses staging slug prefix and configured target base URL outside production', async () => {
process.env.NODE_ENV = 'staging';
process.env.URL_SHORTENER_TARGET_BASE_URL =
'https://staging.lolympus.pages.dev/';
global.fetch = jest.fn().mockResolvedValue({
ok: true,
status: 201,
json: jest
.fn()
.mockResolvedValue({ shortUrl: 'https://go.dahyeon.us/lmtsCD34' }),
} as unknown as Response);
const { service } = makeService();
await service.shortenMatchLink({
matchId: '444444444444444444444444',
shortCode: 'cd34',
});
const init = (global.fetch as jest.Mock).mock.calls[0][1] as RequestInit;
expect(JSON.parse(init.body as string)).toEqual(
expect.objectContaining({
slug: 'lmtsCD34',
url: 'https://staging.lolympus.pages.dev/match/444444444444444444444444',
}),
);
});
it('builds the direct match detail URL for fallback output', () => {
process.env.URL_SHORTENER_TARGET_BASE_URL =
'https://staging.lolympus.pages.dev/';
const { service } = makeService();
expect(service.buildMatchDetailUrl('444444444444444444444444')).toBe(
'https://staging.lolympus.pages.dev/match/444444444444444444444444',
);
});
it('skips shortener calls when the bearer token is missing', async () => {
global.fetch = jest.fn();
const { service } = makeService('');
await expect(
service.shortenMatchLink({
matchId: '333333333333333333333333',
shortCode: 'AB12',
}),
).resolves.toBeUndefined();
expect(global.fetch).not.toHaveBeenCalled();
});
it('returns the deterministic short URL when the slug already exists', async () => {
process.env.NODE_ENV = 'prod';
global.fetch = jest.fn().mockResolvedValue({
ok: false,
status: 409,
text: jest.fn().mockResolvedValue('Conflict'),
} as unknown as Response);
const { service } = makeService();
await expect(
service.shortenMatchLink({
matchId: '333333333333333333333333',
shortCode: 'AB12',
}),
).resolves.toBe('https://go.dahyeon.us/lmtpAB12');
});
it('returns undefined when the shortener rejects the request', async () => {
global.fetch = jest.fn().mockResolvedValue({
ok: false,
status: 500,
text: jest.fn().mockResolvedValue('server error'),
} as unknown as Response);
const { service } = makeService();
await expect(
service.shortenMatchLink({
matchId: '333333333333333333333333',
shortCode: 'AB12',
}),
).resolves.toBeUndefined();
});
});
@@ -0,0 +1,180 @@
import { Injectable, Logger } from '@nestjs/common';
import { SecretService } from '../global/secret/secret.service';
const DEFAULT_SHORTENER_API_URL = 'https://go.dahyeon.us/api/shorten';
const DEFAULT_SHORTENER_BASE_URL = 'https://go.dahyeon.us';
const DEFAULT_TARGET_BASE_URL = 'https://lolympus.dahyeon.us';
const DEFAULT_TIMEOUT_MS = 1500;
interface ShortenMatchLinkParams {
matchId: string;
shortCode: string | undefined;
}
interface ShortenerResponseBody {
shortUrl?: unknown;
}
@Injectable()
export class DakaoUrlShortenerService {
private readonly logger = new Logger(DakaoUrlShortenerService.name);
constructor(private readonly secretService: SecretService) {}
public async shortenMatchLink(
params: ShortenMatchLinkParams,
): Promise<string | undefined> {
const shortCode = params.shortCode?.trim().toUpperCase();
if (!shortCode) return undefined;
const token = await this.resolveToken();
if (!token) return undefined;
const slug = `${this.resolveSlugPrefix()}${shortCode}`;
const requestBody = {
slug,
url: this.buildMatchDetailUrl(params.matchId),
redirectStatus: 302,
expiresAt: null,
};
const controller = new AbortController();
const timeout = setTimeout(
() => controller.abort(),
this.resolveTimeoutMs(),
);
try {
const response = await fetch(this.resolveApiUrl(), {
method: 'POST',
headers: {
Accept: 'application/json',
Authorization: `Bearer ${token}`,
'Content-Type': 'application/json',
},
body: JSON.stringify(requestBody),
signal: controller.signal,
});
if (response.status === 409) {
return this.buildShortUrl(slug);
}
if (!response.ok) {
await this.logFailedResponse(response, slug);
return undefined;
}
const payload = await this.parseResponseBody(response);
const shortUrl = payload?.shortUrl;
return typeof shortUrl === 'string' && shortUrl.trim()
? shortUrl.trim()
: this.buildShortUrl(slug);
} catch (error) {
this.logger.warn(
`URL shortener request failed for slug="${slug}": ${error instanceof Error ? error.message : String(error)}`,
);
return undefined;
} finally {
clearTimeout(timeout);
}
}
private async resolveToken(): Promise<string | undefined> {
try {
const token = await this.secretService.get<string>(
'URL_SHORTENER_TOKEN',
'',
);
return token.trim() || undefined;
} catch (error) {
this.logger.warn(
`URL shortener token unavailable: ${error instanceof Error ? error.message : String(error)}`,
);
return undefined;
}
}
private resolveSlugPrefix(): 'lmtp' | 'lmts' {
const nodeEnv = process.env.NODE_ENV?.trim().toLowerCase();
return nodeEnv === 'prod' || nodeEnv === 'production' ? 'lmtp' : 'lmts';
}
public buildMatchDetailUrl(matchId: string): string {
return `${this.resolveTargetBaseUrl()}/match/${encodeURIComponent(matchId)}`;
}
private buildShortUrl(slug: string): string {
return `${this.resolveShortenerBaseUrl()}/${encodeURIComponent(slug)}`;
}
private resolveApiUrl(): string {
return (
process.env.URL_SHORTENER_API_URL?.trim() || DEFAULT_SHORTENER_API_URL
);
}
private resolveShortenerBaseUrl(): string {
return (
this.normalizeBaseUrl(process.env.URL_SHORTENER_BASE_URL) ??
this.normalizeOrigin(this.resolveApiUrl()) ??
DEFAULT_SHORTENER_BASE_URL
);
}
private resolveTargetBaseUrl(): string {
return (
this.normalizeBaseUrl(process.env.URL_SHORTENER_TARGET_BASE_URL) ??
this.normalizeBaseUrl(process.env.WEB_ORIGIN) ??
DEFAULT_TARGET_BASE_URL
);
}
private resolveTimeoutMs(): number {
const configured = Number(process.env.URL_SHORTENER_TIMEOUT_MS);
return Number.isFinite(configured) && configured > 0
? configured
: DEFAULT_TIMEOUT_MS;
}
private normalizeBaseUrl(value: string | undefined): string | undefined {
const raw = value?.split(',')[0]?.trim();
if (!raw) return undefined;
try {
const url = new URL(raw);
const pathname = url.pathname.replace(/\/+$/u, '');
return `${url.origin}${pathname}`;
} catch {
return undefined;
}
}
private normalizeOrigin(value: string): string | undefined {
try {
return new URL(value).origin;
} catch {
return undefined;
}
}
private async parseResponseBody(
response: Response,
): Promise<ShortenerResponseBody | undefined> {
try {
return (await response.json()) as ShortenerResponseBody;
} catch {
return undefined;
}
}
private async logFailedResponse(
response: Response,
slug: string,
): Promise<void> {
const body = await response.text().catch(() => '');
this.logger.warn(
`URL shortener returned ${response.status} for slug="${slug}"${body ? `: ${body.slice(0, 200)}` : ''}`,
);
}
}
@@ -10,6 +10,7 @@ import { DakaoOutboxSweeperService } from './dakao-outbox-sweeper.service';
import { DakaoOutboxService } from './dakao-outbox.service'; import { DakaoOutboxService } from './dakao-outbox.service';
import { DakaoUserService } from './dakao-user.service'; import { DakaoUserService } from './dakao-user.service';
import { DakaoSendResultSubscriber } from './dakao-send-result.subscriber'; import { DakaoSendResultSubscriber } from './dakao-send-result.subscriber';
import { DakaoUrlShortenerService } from './dakao-url-shortener.service';
import { AccountRegisterHandler } from './handlers/account-register.handler'; import { AccountRegisterHandler } from './handlers/account-register.handler';
import { MatchCancelHandler } from './handlers/match-cancel.handler'; import { MatchCancelHandler } from './handlers/match-cancel.handler';
import { MatchJoinHandler } from './handlers/match-join.handler'; import { MatchJoinHandler } from './handlers/match-join.handler';
@@ -32,6 +33,7 @@ import { PrimaryAccountChangeHandler } from './handlers/primary-account-change.h
DakaoSubscriber, DakaoSubscriber,
DakaoSendResultSubscriber, DakaoSendResultSubscriber,
DakaoUserService, DakaoUserService,
DakaoUrlShortenerService,
AccountRegisterHandler, AccountRegisterHandler,
MatchListHandler, MatchListHandler,
MatchJoinHandler, MatchJoinHandler,
@@ -0,0 +1,107 @@
import { DakaoSubscriber } from './dakao.subscriber';
import { DakaoInboundEvent, DakaoSegment } from './dakao.types';
import { CommandParseError } from './parsers/command.parser';
function makeSubscriber(): DakaoSubscriber {
return new DakaoSubscriber(
{} as never,
{} as never,
{} as never,
{} as never,
{} as never,
{} as never,
{} as never,
{} as never,
{} as never,
{} as never,
{} as never,
{} as never,
);
}
const event = {
projectId: '111111111111111111111111',
chatroomId: 'chatroom-1',
nickname: '프리리',
userId: '12345',
origin: {
chatId: 'chat-1',
logId: 'log-1',
chatLog: {
logId: 'log-1',
chatId: 'chat-1',
authorId: '12345',
type: 1,
sendAt: 0,
message: '!내전',
},
},
} satisfies DakaoInboundEvent;
describe('DakaoSubscriber', () => {
it('renders usage help with star emoticon command lines', () => {
const subscriber = makeSubscriber() as unknown as {
parseErrorReply: (
event: DakaoInboundEvent,
senderNickname: string,
err: CommandParseError,
) => DakaoSegment[];
};
const segments = subscriber.parseErrorReply(
event,
'프리리',
new CommandParseError('usage'),
);
expect(segments).toEqual([
{ kind: 'mention', userId: '12345', displayText: '프리리' },
{ kind: 'text', text: ' 사용법\n' },
{ kind: 'emoticon', id: '1200281_035', altText: '스타' },
{ kind: 'text', text: ' !내전 일정\n' },
{ kind: 'emoticon', id: '1200281_035', altText: '스타' },
{
kind: 'text',
text: ' !내전 신청 코드 소환사이름#태그 포지션1,포지션2\n',
},
{ kind: 'emoticon', id: '1200281_035', altText: '스타' },
{ kind: 'text', text: ' !내전 계정등록 소환사이름#태그\n' },
{ kind: 'emoticon', id: '1200281_035', altText: '스타' },
{
kind: 'text',
text: ' !내전 선호포지션등록 포지션1,포지션2\n',
},
{ kind: 'emoticon', id: '1200281_035', altText: '스타' },
{
kind: 'text',
text: ' !내전 대표계정변경 소환사이름#태그',
},
]);
});
it('keeps the unknown command header before star emoticon usage lines', () => {
const subscriber = makeSubscriber() as unknown as {
parseErrorReply: (
event: DakaoInboundEvent,
senderNickname: string,
err: CommandParseError,
) => DakaoSegment[];
};
const segments = subscriber.parseErrorReply(
event,
'프리리',
new CommandParseError('unknown_command', '폭파'),
);
expect(segments.slice(0, 2)).toEqual([
{ kind: 'mention', userId: '12345', displayText: '프리리' },
{ kind: 'text', text: ' 알 수 없는 명령어입니다.\n' },
]);
expect(segments).toContainEqual({
kind: 'emoticon',
id: '1200281_035',
altText: '스타',
});
});
});
+25 -2
View File
@@ -21,6 +21,13 @@ export class DakaoSubscriber implements OnModuleInit {
private readonly logger = new Logger(DakaoSubscriber.name); private readonly logger = new Logger(DakaoSubscriber.name);
private readonly natsNames = resolveDakaoNatsNames(); private readonly natsNames = resolveDakaoNatsNames();
private botUserId: string | undefined; private botUserId: string | undefined;
private readonly usageCommands = [
'!내전 일정',
'!내전 신청 코드 소환사이름#태그 포지션1,포지션2',
'!내전 계정등록 소환사이름#태그',
'!내전 선호포지션등록 포지션1,포지션2',
'!내전 대표계정변경 소환사이름#태그',
];
constructor( constructor(
private readonly natsService: NatsService, private readonly natsService: NatsService,
@@ -267,9 +274,9 @@ export class DakaoSubscriber implements OnModuleInit {
const text = ((): string => { const text = ((): string => {
switch (err.code) { switch (err.code) {
case 'unknown_command': case 'unknown_command':
return ` 알 수 없는 명령어입니다. 사용법: !내전 일정, !내전 계정등록 <게임명>#<태그>, !내전 대표계정변경 <게임명>#<태그>, !내전 선호포지션등록 미드,정글, !내전 신청 [코드] [게임명#태그] [포지션1,포지션2], !내전 취소 <코드>`; return ` 알 수 없는 명령어입니다.\n`;
case 'usage': case 'usage':
return ` 사용법: !내전 일정, !내전 계정등록 <게임명>#<태그>, !내전 대표계정변경 <게임명>#<태그>, !내전 선호포지션등록 미드,정글, !내전 신청 [코드] [게임명#태그] [포지션1,포지션2], !내전 취소 <코드>`; return ` 내전 명령어 사용법\n`;
case 'invalid_match_id': case 'invalid_match_id':
return ` 매치 ID 형식이 올바르지 않습니다 (${err.detail ?? ''}).`; return ` 매치 ID 형식이 올바르지 않습니다 (${err.detail ?? ''}).`;
case 'invalid_riot_id': case 'invalid_riot_id':
@@ -280,6 +287,22 @@ export class DakaoSubscriber implements OnModuleInit {
return ` 명령을 처리할 수 없습니다.`; return ` 명령을 처리할 수 없습니다.`;
} }
})(); })();
if (err.code === 'unknown_command' || err.code === 'usage') {
return [...head, { kind: 'text', text }, ...this.usageCommandSegments()];
}
return [...head, { kind: 'text', text }]; return [...head, { kind: 'text', text }];
} }
private usageCommandSegments(): DakaoSegment[] {
return this.usageCommands.flatMap((command, index) => [
{ kind: 'emoticon', id: '1200281_035', altText: '스타' } as const,
{
kind: 'text',
text:
index === this.usageCommands.length - 1
? ` ${command}`
: ` ${command} \n`,
} as const,
]);
}
} }
@@ -1,11 +1,28 @@
import mongoose from 'mongoose'; import mongoose from 'mongoose';
import { MatchService } from '../../match/match.service'; import { MatchService } from '../../match/match.service';
import { DakaoUrlShortenerService } from '../dakao-url-shortener.service';
import { MatchListHandler } from './match-list.handler'; import { MatchListHandler } from './match-list.handler';
const objectId = (hex: string) => new mongoose.Types.ObjectId(hex); const objectId = (hex: string) => new mongoose.Types.ObjectId(hex);
function makeHandler(params: {
matchService: Partial<MatchService>;
urlShortener?: Partial<DakaoUrlShortenerService>;
}): MatchListHandler {
return new MatchListHandler(
params.matchService as MatchService,
{
shortenMatchLink: jest.fn().mockResolvedValue(undefined),
buildMatchDetailUrl: jest.fn(
(matchId: string) => `https://lolympus.dahyeon.us/match/${matchId}`,
),
...params.urlShortener,
} as unknown as DakaoUrlShortenerService,
);
}
describe('MatchListHandler', () => { describe('MatchListHandler', () => {
it('prints short codes and compact KST dates', async () => { it('prints short codes, compact KST dates, and short links', async () => {
const match = { const match = {
_id: objectId('333333333333333333333333'), _id: objectId('333333333333333333333333'),
title: '토요 내전', title: '토요 내전',
@@ -17,8 +34,13 @@ describe('MatchListHandler', () => {
const matchService = { const matchService = {
list: jest.fn().mockResolvedValue([match]), list: jest.fn().mockResolvedValue([match]),
ensureShortCode: jest.fn().mockResolvedValue(match), ensureShortCode: jest.fn().mockResolvedValue(match),
} as unknown as MatchService; };
const handler = new MatchListHandler(matchService); const urlShortener = {
shortenMatchLink: jest
.fn()
.mockResolvedValue('https://go.dahyeon.us/lmtpAB12'),
};
const handler = makeHandler({ matchService, urlShortener });
const segments = await handler.handle({ const segments = await handler.handle({
communityId: objectId('111111111111111111111111'), communityId: objectId('111111111111111111111111'),
@@ -27,6 +49,10 @@ describe('MatchListHandler', () => {
}); });
expect(matchService.ensureShortCode).toHaveBeenCalledWith(match); expect(matchService.ensureShortCode).toHaveBeenCalledWith(match);
expect(urlShortener.shortenMatchLink).toHaveBeenCalledWith({
matchId: '333333333333333333333333',
shortCode: 'AB12',
});
expect(segments[1]).toMatchObject({ expect(segments[1]).toMatchObject({
kind: 'text', kind: 'text',
text: expect.stringContaining('토요 내전 (2/10) 5/2 19:30'), text: expect.stringContaining('토요 내전 (2/10) 5/2 19:30'),
@@ -35,6 +61,10 @@ describe('MatchListHandler', () => {
kind: 'text', kind: 'text',
text: expect.stringContaining('코드: AB12'), text: expect.stringContaining('코드: AB12'),
}); });
expect(segments[1]).toMatchObject({
kind: 'text',
text: expect.stringContaining('링크: https://go.dahyeon.us/lmtpAB12'),
});
expect(segments[1]).toMatchObject({ expect(segments[1]).toMatchObject({
kind: 'text', kind: 'text',
text: expect.not.stringContaining('2026-05-02'), text: expect.not.stringContaining('2026-05-02'),
@@ -43,5 +73,50 @@ describe('MatchListHandler', () => {
kind: 'text', kind: 'text',
text: expect.not.stringContaining('ID:'), text: expect.not.stringContaining('ID:'),
}); });
expect(segments[1]).toMatchObject({
kind: 'text',
text: expect.not.stringContaining('계정등록:'),
});
expect(segments[1]).toMatchObject({
kind: 'text',
text: expect.not.stringContaining('신청:'),
});
});
it('falls back to a direct match detail link when short link creation is skipped', async () => {
const match = {
_id: objectId('333333333333333333333333'),
title: '토요 내전',
shortCode: 'AB12',
participants: [],
maxParticipants: 10,
scheduledAt: new Date('2026-05-02T10:30:00.000Z'),
};
const handler = makeHandler({
matchService: {
list: jest.fn().mockResolvedValue([match]),
ensureShortCode: jest.fn().mockResolvedValue(match),
},
urlShortener: {
shortenMatchLink: jest.fn().mockResolvedValue(undefined),
},
});
const segments = await handler.handle({
communityId: objectId('111111111111111111111111'),
senderUserId: 'kakao-user-1',
senderNickname: '프리리',
});
expect(segments[1]).toMatchObject({
kind: 'text',
text: expect.stringContaining('코드: AB12'),
});
expect(segments[1]).toMatchObject({
kind: 'text',
text: expect.stringContaining(
'링크: https://lolympus.dahyeon.us/match/333333333333333333333333',
),
});
}); });
}); });
@@ -1,11 +1,18 @@
import { Injectable } from '@nestjs/common'; import { Injectable, Logger } from '@nestjs/common';
import mongoose from 'mongoose'; import mongoose from 'mongoose';
import { MatchDocument } from '../../global/database/schema';
import { MatchService } from '../../match/match.service'; import { MatchService } from '../../match/match.service';
import { DakaoSegment } from '../dakao.types'; import { DakaoSegment } from '../dakao.types';
import { DakaoUrlShortenerService } from '../dakao-url-shortener.service';
@Injectable() @Injectable()
export class MatchListHandler { export class MatchListHandler {
constructor(private readonly matchService: MatchService) {} private readonly logger = new Logger(MatchListHandler.name);
constructor(
private readonly matchService: MatchService,
private readonly urlShortener: DakaoUrlShortenerService,
) {}
public async handle(params: { public async handle(params: {
communityId: mongoose.Types.ObjectId; communityId: mongoose.Types.ObjectId;
@@ -33,12 +40,16 @@ export class MatchListHandler {
matches.map((match) => this.matchService.ensureShortCode(match)), matches.map((match) => this.matchService.ensureShortCode(match)),
); );
const lines = matchesWithCodes.map((m, i) => { const lines = await Promise.all(
const filled = m.participants.length; matchesWithCodes.map(async (m, i) => {
const cap = m.maxParticipants; const filled = m.participants.length;
const time = formatScheduledAt(m.scheduledAt); const cap = m.maxParticipants;
return `\n${i + 1}. ${m.title} (${filled}/${cap}) ${time}\n 코드: ${m.shortCode}`; const time = formatScheduledAt(m.scheduledAt);
}); const shortUrl = await this.createShortUrl(m);
const linkLine = shortUrl ? `\n 링크: ${shortUrl}` : '';
return `\n${i + 1}. ${m.title} (${filled}/${cap}) ${time}\n 코드: ${m.shortCode}${linkLine}`;
}),
);
return [ return [
{ {
@@ -48,10 +59,29 @@ export class MatchListHandler {
}, },
{ {
kind: 'text', kind: 'text',
text: ` 모집 중인 내전 ${matches.length}건${lines.join('')}\n계정등록: !내전 계정등록 <닉네임>#<태그>\n대표계정변경: !내전 대표계정변경 <닉네임>#<태그>\n선호포지션등록: !내전 선호포지션등록 미드,정글\n신청: !내전 신청 <코드> [닉네임#태그] [포지션1,포지션2]\n취소: !내전 취소 <코드>\n계정/선호포지션을 등록해두면 !내전 신청 <코드> 로 신청할 수 있습니다.`, text: ` 모집 중인 내전 ${matches.length}건${lines.join('')}`,
}, },
]; ];
} }
private async createShortUrl(
match: MatchDocument,
): Promise<string | undefined> {
try {
const shortUrl = await this.urlShortener.shortenMatchLink({
matchId: String(match._id),
shortCode: match.shortCode,
});
return (
shortUrl ?? this.urlShortener.buildMatchDetailUrl(String(match._id))
);
} catch (error) {
this.logger.warn(
`Failed to create dakao match short URL for match="${String(match._id)}": ${error instanceof Error ? error.message : String(error)}`,
);
return this.urlShortener.buildMatchDetailUrl(String(match._id));
}
}
} }
function formatScheduledAt(date: Date): string { function formatScheduledAt(date: Date): string {
@@ -155,6 +155,10 @@ describe('parseCommand', () => {
expect(() => parseCommand('안녕하세요')).toThrow(/not_a_command/); expect(() => parseCommand('안녕하세요')).toThrow(/not_a_command/);
}); });
it('throws usage for bare command prefix', () => {
expect(() => parseCommand('!내전')).toThrow(/usage/);
});
it('throws unknown_command for unrecognized subcommands', () => { it('throws unknown_command for unrecognized subcommands', () => {
expect(() => parseCommand('!내전 폭파')).toThrow(/unknown_command/); expect(() => parseCommand('!내전 폭파')).toThrow(/unknown_command/);
}); });
+26 -4
View File
@@ -72,16 +72,27 @@ export class MatchController {
communityId: mongoose.Types.ObjectId, communityId: mongoose.Types.ObjectId,
@Query('status') status?: MatchStatus, @Query('status') status?: MatchStatus,
@Query('limit') limit?: string, @Query('limit') limit?: string,
@Query('page') page?: string,
@Query('offset') offset?: string,
@Query('scheduledFrom') scheduledFrom?: string,
@Query('scheduledTo') scheduledTo?: string,
@Query('sort') sort?: 'asc' | 'desc',
) { ) {
const matches = await this.matchService.list({ const result = await this.matchService.listPage({
communityId, communityId,
status, status,
limit: limit ? Number(limit) : undefined, limit: this.toOptionalNumber(limit),
page: this.toOptionalNumber(page),
offset: this.toOptionalNumber(offset),
scheduledFrom: this.toOptionalDate(scheduledFrom),
scheduledTo: this.toOptionalDate(scheduledTo),
sort,
}); });
if (!currentUser) return { matches }; if (!currentUser) return result;
const myId = currentUser._id; const myId = currentUser._id;
return { return {
matches: matches.map((m) => this.annotateJoined(m, myId)), ...result,
matches: result.matches.map((m) => this.annotateJoined(m, myId)),
}; };
} }
@@ -211,4 +222,15 @@ export class MatchController {
throw new BadRequestException('Different community.'); throw new BadRequestException('Different community.');
} }
} }
private toOptionalNumber(value?: string): number | undefined {
const numberValue = Number(value);
return Number.isFinite(numberValue) ? numberValue : undefined;
}
private toOptionalDate(value?: string): Date | undefined {
if (!value) return undefined;
const date = new Date(value);
return Number.isNaN(date.getTime()) ? undefined : date;
}
} }
@@ -36,6 +36,135 @@ describe('MatchService', () => {
}; };
} }
function createServiceWithListModel() {
const exec = jest.fn().mockResolvedValue([{ title: 'second page' }]);
const limit = jest.fn().mockReturnValue({ exec });
const skip = jest.fn().mockReturnValue({ limit });
const sort = jest.fn().mockReturnValue({ skip });
const find = jest.fn().mockReturnValue({ sort });
const countExec = jest.fn().mockResolvedValue(12);
const countDocuments = jest.fn().mockReturnValue({ exec: countExec });
const MatchModel = {
find,
countDocuments,
};
const connectionService = {
getModel: jest.fn().mockImplementation(async (name: string) => {
if (name === 'match') return MatchModel;
return {};
}),
};
const tournamentCodeService = {
buildSlots: jest.fn().mockResolvedValue([]),
releaseFromMatch: jest.fn().mockResolvedValue(undefined),
};
const communityStatsService = {
invalidateCommunity: jest.fn().mockResolvedValue(undefined),
};
const matchStatsService = {
buildAndUpsert: jest.fn().mockResolvedValue(undefined),
removeByMatch: jest.fn().mockResolvedValue(undefined),
};
return {
service: new MatchService(
connectionService as never,
tournamentCodeService as never,
communityStatsService as never,
matchStatsService as never,
),
MatchModel,
sort,
skip,
limit,
};
}
it('returns a paginated match list with total count', async () => {
const communityId = new mongoose.Types.ObjectId();
const { service, MatchModel, sort, skip, limit } =
createServiceWithListModel();
const page = await service.listPage({
communityId,
page: 2,
limit: 5,
});
expect(MatchModel.find).toHaveBeenCalledWith({ communityId });
expect(MatchModel.countDocuments).toHaveBeenCalledWith({ communityId });
expect(sort).toHaveBeenCalledWith({ scheduledAt: -1 });
expect(skip).toHaveBeenCalledWith(5);
expect(limit).toHaveBeenCalledWith(5);
expect(page).toEqual({
matches: [{ title: 'second page' }],
total: 12,
page: 2,
limit: 5,
});
});
it('applies offset before page-based pagination', async () => {
const communityId = new mongoose.Types.ObjectId();
const { service, skip } = createServiceWithListModel();
const page = await service.listPage({
communityId,
offset: 4,
page: 2,
limit: 5,
});
expect(skip).toHaveBeenCalledWith(9);
expect(page.total).toBe(8);
});
it('filters future matches and sorts oldest first for upcoming sections', async () => {
const communityId = new mongoose.Types.ObjectId();
const scheduledFrom = new Date('2026-06-08T12:00:00.000Z');
const { service, MatchModel, sort } = createServiceWithListModel();
await service.listPage({
communityId,
scheduledFrom,
sort: 'asc',
limit: 4,
});
expect(MatchModel.find).toHaveBeenCalledWith({
communityId,
scheduledAt: { $gte: scheduledFrom },
});
expect(MatchModel.countDocuments).toHaveBeenCalledWith({
communityId,
scheduledAt: { $gte: scheduledFrom },
});
expect(sort).toHaveBeenCalledWith({ scheduledAt: 1 });
});
it('filters past matches and keeps newest first for history sections', async () => {
const communityId = new mongoose.Types.ObjectId();
const scheduledTo = new Date('2026-06-08T12:00:00.000Z');
const { service, MatchModel, sort } = createServiceWithListModel();
await service.listPage({
communityId,
scheduledTo,
sort: 'desc',
limit: 10,
});
expect(MatchModel.find).toHaveBeenCalledWith({
communityId,
scheduledAt: { $lt: scheduledTo },
});
expect(MatchModel.countDocuments).toHaveBeenCalledWith({
communityId,
scheduledAt: { $lt: scheduledTo },
});
expect(sort).toHaveBeenCalledWith({ scheduledAt: -1 });
});
it('clears game schedule when a built match returns to recruiting', async () => { it('clears game schedule when a built match returns to recruiting', async () => {
const communityId = new mongoose.Types.ObjectId(); const communityId = new mongoose.Types.ObjectId();
const match = { const match = {
+89 -9
View File
@@ -23,6 +23,8 @@ import { TournamentCodeService } from '../tournament-code/tournament-code.servic
const MATCH_SHORT_CODE_ALPHABET = 'ABCDEFGHJKLMNPQRSTUVWXYZ23456789'; const MATCH_SHORT_CODE_ALPHABET = 'ABCDEFGHJKLMNPQRSTUVWXYZ23456789';
const MATCH_SHORT_CODE_LENGTH = 4; const MATCH_SHORT_CODE_LENGTH = 4;
const MATCH_SHORT_CODE_GENERATION_ATTEMPTS = 20; const MATCH_SHORT_CODE_GENERATION_ATTEMPTS = 20;
const DEFAULT_MATCH_LIST_LIMIT = 50;
const MAX_MATCH_LIST_LIMIT = 200;
interface CreateMatchParams { interface CreateMatchParams {
communityId: mongoose.Types.ObjectId; communityId: mongoose.Types.ObjectId;
@@ -40,6 +42,23 @@ interface ListMatchesQuery {
communityId: mongoose.Types.ObjectId; communityId: mongoose.Types.ObjectId;
status?: MatchStatus; status?: MatchStatus;
limit?: number; limit?: number;
scheduledFrom?: Date;
scheduledTo?: Date;
sort?: 'asc' | 'desc';
}
interface ListMatchesPageQuery extends ListMatchesQuery {
page?: number;
offset?: number;
}
interface MatchListFilter {
communityId: mongoose.Types.ObjectId;
status?: MatchStatus;
scheduledAt?: {
$gte?: Date;
$lt?: Date;
};
} }
interface JoinMatchParams { interface JoinMatchParams {
@@ -101,19 +120,42 @@ export class MatchService {
public async list(query: ListMatchesQuery): Promise<MatchDocument[]> { public async list(query: ListMatchesQuery): Promise<MatchDocument[]> {
const MatchModel = await this.connectionService.getModel('match'); const MatchModel = await this.connectionService.getModel('match');
const filter: { const filter = this.buildListFilter(query);
communityId: mongoose.Types.ObjectId;
status?: MatchStatus;
} = {
communityId: query.communityId,
};
if (query.status) filter.status = query.status;
return MatchModel.find(filter) return MatchModel.find(filter)
.sort({ scheduledAt: -1 }) .sort(this.buildListSort(query.sort))
.limit(Math.min(query.limit ?? 50, 200)) .limit(this.normalizeListLimit(query.limit))
.exec(); .exec();
} }
public async listPage(query: ListMatchesPageQuery): Promise<{
matches: MatchDocument[];
total: number;
page: number;
limit: number;
}> {
const MatchModel = await this.connectionService.getModel('match');
const filter = this.buildListFilter(query);
const page = this.normalizeListPage(query.page);
const limit = this.normalizeListLimit(query.limit);
const offset = this.normalizeListOffset(query.offset);
const skip = offset + (page - 1) * limit;
const [matches, rawTotal] = await Promise.all([
MatchModel.find(filter)
.sort(this.buildListSort(query.sort))
.skip(skip)
.limit(limit)
.exec(),
MatchModel.countDocuments(filter).exec(),
]);
return {
matches,
total: Math.max(rawTotal - offset, 0),
page,
limit,
};
}
public async ensureShortCode(match: MatchDocument): Promise<MatchDocument> { public async ensureShortCode(match: MatchDocument): Promise<MatchDocument> {
if (match.shortCode) return match; if (match.shortCode) return match;
@@ -394,6 +436,44 @@ export class MatchService {
}; };
} }
private buildListFilter(query: ListMatchesQuery): MatchListFilter {
const filter: MatchListFilter = {
communityId: query.communityId,
};
if (query.status) filter.status = query.status;
if (query.scheduledFrom || query.scheduledTo) {
filter.scheduledAt = {};
if (query.scheduledFrom) filter.scheduledAt.$gte = query.scheduledFrom;
if (query.scheduledTo) filter.scheduledAt.$lt = query.scheduledTo;
}
return filter;
}
private buildListSort(sort?: 'asc' | 'desc'): { scheduledAt: 1 | -1 } {
return { scheduledAt: sort === 'asc' ? 1 : -1 };
}
private normalizeListLimit(limit?: number): number {
if (!Number.isFinite(limit) || !limit || limit < 1) {
return DEFAULT_MATCH_LIST_LIMIT;
}
return Math.min(Math.floor(limit), MAX_MATCH_LIST_LIMIT);
}
private normalizeListPage(page?: number): number {
if (!Number.isFinite(page) || !page || page < 1) {
return 1;
}
return Math.floor(page);
}
private normalizeListOffset(offset?: number): number {
if (!Number.isFinite(offset) || !offset || offset < 1) {
return 0;
}
return Math.floor(offset);
}
private async generateUniqueShortCode( private async generateUniqueShortCode(
MatchModel: mongoose.Model<Match>, MatchModel: mongoose.Model<Match>,
communityId: mongoose.Types.ObjectId, communityId: mongoose.Types.ObjectId,
+133 -46
View File
@@ -1,4 +1,5 @@
import { BrowserRouter, Link, Route, Routes } from "react-router"; import { BrowserRouter, Link, Route, Routes } from "react-router";
import type { ReactNode } from "react";
import { useMsal } from "@azure/msal-react"; import { useMsal } from "@azure/msal-react";
import { Moon, Sun } from "lucide-react"; import { Moon, Sun } from "lucide-react";
import DevAuthSwitcher from "./components/DevAuthSwitcher"; import DevAuthSwitcher from "./components/DevAuthSwitcher";
@@ -26,7 +27,7 @@ function MsalHeaderActions() {
if (!account) { if (!account) {
return ( return (
<Link <Link
className="btn btn-ghost btn-xs px-2 text-base-content/60 hover:text-base-content" className="btn btn-ghost btn-sm px-2 text-base-content/60 hover:text-base-content"
to="/login" to="/login"
> >
로그인 로그인
@@ -37,10 +38,11 @@ function MsalHeaderActions() {
return ( return (
<button <button
type="button" type="button"
className="btn btn-ghost btn-xs px-3" className="btn btn-ghost btn-sm px-3 max-w-[45vw] sm:max-w-none"
onClick={() => void instance.logoutRedirect()} onClick={() => void instance.logoutRedirect()}
> >
{account.name ?? account.username} 로그아웃 <span className="truncate">{account.name ?? account.username}</span>
<span className="hidden shrink-0 sm:inline">로그아웃</span>
</button> </button>
); );
} }
@@ -55,38 +57,85 @@ function ThemeToggle() {
<span className="tooltip tooltip-bottom" data-tip={label}> <span className="tooltip tooltip-bottom" data-tip={label}>
<button <button
type="button" type="button"
className="btn btn-ghost btn-xs btn-square text-base-content/60 hover:text-base-content" className="btn btn-ghost btn-sm btn-square text-base-content/60 hover:text-base-content"
aria-label={label} aria-label={label}
onClick={() => setTheme(nextTheme)} onClick={() => setTheme(nextTheme)}
> >
<Icon className="h-3.5 w-3.5" aria-hidden="true" /> <Icon className="size-4" aria-hidden="true" />
</button> </button>
</span> </span>
); );
} }
function AppFooter() {
return (
<footer className="border-t border-base-content/10 bg-base-100">
<div className="max-w-5xl mx-auto px-4 sm:px-6 py-8 text-xs text-base-content/35">
<nav className="flex items-center gap-4 mb-4 font-semibold text-base-content/45">
<Link to="/terms" className="hover:text-base-content">
서비스 이용약관
</Link>
<Link to="/privacy" className="hover:text-base-content">
개인정보처리방침
</Link>
</nav>
<p className="leading-relaxed max-w-4xl">
© 2026 LOLYMPUS. LOLYMPUS is not endorsed by Riot Games and
does not reflect the views or opinions of Riot Games or anyone
officially involved in producing or managing League of Legends.
League of Legends and Riot Games are trademarks or registered
trademarks of Riot Games, Inc. League of Legends © Riot Games, Inc.
</p>
</div>
</footer>
);
}
function LegalPage({
title,
children,
}: {
title: string;
children: ReactNode;
}) {
return (
<main className="max-w-3xl mx-auto px-4 sm:px-6 py-12">
<Link
to="/"
className="inline-flex text-xs text-base-content/40 hover:text-base-content mb-5"
>
← 홈으로
</Link>
<h1 className="text-2xl font-black text-base-content">{title}</h1>
<div className="mt-6 space-y-4 text-sm leading-7 text-base-content/60">
{children}
</div>
</main>
);
}
function App() { function App() {
const communityQuery = useCommunity(DEFAULT_COMMUNITY_ID); const communityQuery = useCommunity(DEFAULT_COMMUNITY_ID);
const communityLabel = communityQuery.data?.name ?? "LOLYMPUS"; const communityLabel = communityQuery.data?.name ?? "LOLYMPUS";
return ( return (
<BrowserRouter> <BrowserRouter>
<div className="min-h-screen bg-base-100"> <div className="min-h-screen bg-base-100 flex flex-col">
<nav className="bg-base-100 border-b border-base-content/10 sticky top-0 z-50"> <nav className="bg-base-100 border-b border-base-content/10 sticky top-0 z-50">
<div className="max-w-5xl mx-auto px-4 sm:px-6 flex items-center justify-between h-11"> <div className="max-w-5xl mx-auto px-4 sm:px-6 flex items-center justify-between h-12">
<Link <Link
className="text-sm font-bold tracking-tight text-base-content" className="text-base font-bold tracking-tight text-base-content"
to="/" to="/"
> >
{communityLabel} {communityLabel}
</Link> </Link>
<div className="flex items-center gap-3"> <div className="flex items-center gap-3">
{/* {DEFAULT_COMMUNITY_ID ? ( {/* {DEFAULT_COMMUNITY_ID ? (
<span className="text-[10px] uppercase tracking-wider text-base-content/25"> <span className="text-xs uppercase tracking-wider text-base-content/25">
API Live API Live
</span> </span>
) : ( ) : (
<span className="text-[10px] uppercase tracking-wider text-amber-500/70"> <span className="text-xs uppercase tracking-wider text-amber-500/70">
Set `VITE_DEFAULT_COMMUNITY_ID` Set `VITE_DEFAULT_COMMUNITY_ID`
</span> </span>
)} */} )} */}
@@ -96,42 +145,80 @@ function App() {
</div> </div>
</nav> </nav>
<Routes> <div className="flex-1">
<Route path="/" element={<HomePage />} /> <Routes>
<Route path="/login" element={<LoginPage />} /> <Route path="/" element={<HomePage />} />
<Route path="/auth/callback" element={<AuthCallbackPage />} /> <Route path="/login" element={<LoginPage />} />
<Route path="/match/:id" element={<MatchDetailPage />} /> <Route path="/auth/callback" element={<AuthCallbackPage />} />
<Route <Route path="/match/:id" element={<MatchDetailPage />} />
path="/match/:id/team/:teamIndex" <Route
element={<MatchTeamProgressPage />} path="/match/:id/team/:teamIndex"
/> element={<MatchTeamProgressPage />}
<Route path="/match/:id/auction" element={<AuctionPage />} /> />
<Route path="/users/:userId/history" element={<UserHistoryPage />} /> <Route path="/match/:id/auction" element={<AuctionPage />} />
<Route <Route path="/users/:userId/history" element={<UserHistoryPage />} />
path="/communities/:cid/internal-stats" <Route
element={<CommunityInternalStatsPage />} path="/communities/:cid/internal-stats"
/> element={<CommunityInternalStatsPage />}
<Route />
path="/communities/:cid/internal-stats/match/:matchId" <Route
element={<InternalMatchDetailPage />} path="/communities/:cid/internal-stats/match/:matchId"
/> element={<InternalMatchDetailPage />}
<Route />
path="/admin/communities/:cid/matches" <Route
element={<MatchAdminPage />} path="/admin/communities/:cid/matches"
/> element={<MatchAdminPage />}
<Route />
path="/admin/communities/:cid/tournament-codes" <Route
element={<TournamentCodesPage />} path="/admin/communities/:cid/tournament-codes"
/> element={<TournamentCodesPage />}
<Route />
path="/admin/communities/:cid/legacy-import" <Route
element={<LegacyImportPage />} path="/admin/communities/:cid/legacy-import"
/> element={<LegacyImportPage />}
<Route />
path="/admin/communities/:cid/legacy-matches" <Route
element={<LegacyMatchesPage />} path="/admin/communities/:cid/legacy-matches"
/> element={<LegacyMatchesPage />}
</Routes> />
<Route
path="/terms"
element={
<LegalPage title="서비스 이용약관">
<p>
This service is provided for community tournament support,
including match scheduling, participation management, team
organization, and related statistics.
</p>
<p>
By using this service, users agree not to interfere with
service operation, misuse community data, or submit content
that violates applicable laws or community rules.
</p>
</LegalPage>
}
/>
<Route
path="/privacy"
element={
<LegalPage title="개인정보처리방침">
<p>
This service processes account, profile, match
participation, team, and authentication data only as needed
to operate community tournament features.
</p>
<p>
Users may request access, correction, or deletion of their
personal data through the service administrator, subject to
records that must be retained for service integrity or legal
obligations.
</p>
</LegalPage>
}
/>
</Routes>
</div>
<AppFooter />
<DevAuthSwitcher /> <DevAuthSwitcher />
</div> </div>
</BrowserRouter> </BrowserRouter>
+46 -1
View File
@@ -50,6 +50,11 @@ const DDRAGON_MANIFEST_STALE_MS = 24 * 60 * 60 * 1000;
interface MatchesQueryOptions { interface MatchesQueryOptions {
status?: MatchStatus; status?: MatchStatus;
limit?: number; limit?: number;
page?: number;
offset?: number;
scheduledFrom?: string;
scheduledTo?: string;
sort?: 'asc' | 'desc';
} }
export interface UserHistoryFilters { export interface UserHistoryFilters {
@@ -74,6 +79,11 @@ function createMatchesPath(
const searchParams = new URLSearchParams(); const searchParams = new URLSearchParams();
if (options.status) searchParams.set('status', options.status); if (options.status) searchParams.set('status', options.status);
if (options.limit) searchParams.set('limit', String(options.limit)); if (options.limit) searchParams.set('limit', String(options.limit));
if (options.page) searchParams.set('page', String(options.page));
if (options.offset) searchParams.set('offset', String(options.offset));
if (options.scheduledFrom) searchParams.set('scheduledFrom', options.scheduledFrom);
if (options.scheduledTo) searchParams.set('scheduledTo', options.scheduledTo);
if (options.sort) searchParams.set('sort', options.sort);
const queryString = searchParams.toString(); const queryString = searchParams.toString();
return `/communities/${communityId}/matches${queryString ? `?${queryString}` : ''}`; return `/communities/${communityId}/matches${queryString ? `?${queryString}` : ''}`;
@@ -93,7 +103,17 @@ export function useMatches(
communityId = DEFAULT_COMMUNITY_ID, communityId = DEFAULT_COMMUNITY_ID,
) { ) {
return useQuery({ return useQuery({
queryKey: ['matches', communityId, options.status ?? null, options.limit ?? null], queryKey: [
'matches',
communityId,
options.status ?? null,
options.limit ?? null,
options.page ?? null,
options.offset ?? null,
options.scheduledFrom ?? null,
options.scheduledTo ?? null,
options.sort ?? null,
],
queryFn: async () => { queryFn: async () => {
const response = await apiFetch<MatchesResponse>( const response = await apiFetch<MatchesResponse>(
createMatchesPath(communityId, options), createMatchesPath(communityId, options),
@@ -105,6 +125,31 @@ export function useMatches(
}); });
} }
export function useMatchesPage(
options: MatchesQueryOptions,
communityId = DEFAULT_COMMUNITY_ID,
) {
return useQuery({
queryKey: [
'matches-page',
communityId,
options.status ?? null,
options.limit ?? null,
options.page ?? null,
options.offset ?? null,
options.scheduledFrom ?? null,
options.scheduledTo ?? null,
options.sort ?? null,
],
queryFn: () =>
apiFetch<MatchesResponse>(createMatchesPath(communityId, options), {
auth: 'none',
}),
enabled: Boolean(communityId),
placeholderData: (previousData) => previousData,
});
}
export function useMatch(matchId: string | undefined, communityId = DEFAULT_COMMUNITY_ID) { export function useMatch(matchId: string | undefined, communityId = DEFAULT_COMMUNITY_ID) {
return useQuery({ return useQuery({
queryKey: ['match', communityId, matchId ?? null], queryKey: ['match', communityId, matchId ?? null],
+3
View File
@@ -340,6 +340,9 @@ export interface MeResponse {
export interface MatchesResponse { export interface MatchesResponse {
matches: ApiMatch[]; matches: ApiMatch[];
total: number;
page: number;
limit: number;
} }
export interface MatchMutationRequest { export interface MatchMutationRequest {
+3 -3
View File
@@ -22,10 +22,10 @@ export default function DevAuthSwitcher() {
return ( return (
<div className="fixed right-4 bottom-4 z-50 w-72 border border-base-content/10 bg-base-100/95 backdrop-blur px-3 py-3 shadow-xl"> <div className="fixed right-4 bottom-4 z-50 w-72 border border-base-content/10 bg-base-100/95 backdrop-blur px-3 py-3 shadow-xl">
<div className="text-[10px] font-bold uppercase tracking-wider text-base-content/35"> <div className="text-xs font-bold uppercase tracking-wider text-base-content/35">
Dev Auth Dev Auth
</div> </div>
<div className="mt-2 text-[11px] text-base-content/45"> <div className="mt-2 text-xs text-base-content/45">
X-Auth-User-Id X-Auth-User-Id
</div> </div>
<input <input
@@ -50,7 +50,7 @@ export default function DevAuthSwitcher() {
Clear Clear
</button> </button>
</div> </div>
<div className="mt-2 text-[10px] text-base-content/35 break-all"> <div className="mt-2 text-xs text-base-content/35 break-all">
현재값: {authUserId ?? '없음'} 현재값: {authUserId ?? '없음'}
</div> </div>
</div> </div>
+1 -1
View File
@@ -101,7 +101,7 @@ export function RankBadge({
data-tip={tooltip} data-tip={tooltip}
> >
<span <span
className={`inline-flex ${SIZE_CLASSES[size]} shrink-0 items-center justify-center whitespace-nowrap rounded-[3px] border px-1 text-[10px] font-black leading-none ${rankBadgeClass(tier)}`} className={`inline-flex ${SIZE_CLASSES[size]} shrink-0 items-center justify-center whitespace-nowrap rounded-[3px] border px-1 text-xs font-black leading-none ${rankBadgeClass(tier)}`}
aria-label={tooltip} aria-label={tooltip}
> >
{formatRankBadge(tier)} {formatRankBadge(tier)}
+5 -5
View File
@@ -276,7 +276,7 @@ function TierTooltip({
? ` · ${point.wins}승 ${point.losses}패` ? ` · ${point.wins}승 ${point.losses}패`
: ""; : "";
return ( return (
<div className="border border-base-content/15 bg-base-100 px-3 py-2 text-[11px] shadow-lg"> <div className="border border-base-content/15 bg-base-100 px-3 py-2 text-xs shadow-lg">
<div className="font-bold text-base-content">{formatTierLabel(point)}</div> <div className="font-bold text-base-content">{formatTierLabel(point)}</div>
<div className="mt-0.5 text-base-content/45"> <div className="mt-0.5 text-base-content/45">
{new Intl.DateTimeFormat("ko-KR", { {new Intl.DateTimeFormat("ko-KR", {
@@ -386,7 +386,7 @@ export default function TierHistoryChart({
const header = ( const header = (
<div className="flex flex-wrap items-center justify-between gap-2 border-b border-base-content/10 bg-base-200/40 px-4 py-2.5"> <div className="flex flex-wrap items-center justify-between gap-2 border-b border-base-content/10 bg-base-200/40 px-4 py-2.5">
<h2 className="text-[11px] font-bold uppercase tracking-wider text-base-content/40"> <h2 className="text-xs font-bold uppercase tracking-wider text-base-content/40">
티어 변동 티어 변동
</h2> </h2>
<div className="flex items-center gap-1.5"> <div className="flex items-center gap-1.5">
@@ -396,7 +396,7 @@ export default function TierHistoryChart({
key={option} key={option}
type="button" type="button"
onClick={() => setQueue(option)} onClick={() => setQueue(option)}
className={`h-7 px-2 text-[11px] font-semibold border transition-colors ${ className={`h-7 px-2 text-xs font-semibold border transition-colors ${
activeQueue === option activeQueue === option
? "border-primary/30 bg-primary/5 text-primary" ? "border-primary/30 bg-primary/5 text-primary"
: "border-base-content/10 text-base-content/40 hover:text-base-content/70" : "border-base-content/10 text-base-content/40 hover:text-base-content/70"
@@ -406,7 +406,7 @@ export default function TierHistoryChart({
</button> </button>
))} ))}
<select <select
className="h-7 border border-base-content/10 bg-base-100 px-2 text-[11px] text-base-content focus:border-primary/30 focus:outline-none" className="h-7 border border-base-content/10 bg-base-100 px-2 text-xs text-base-content focus:border-primary/30 focus:outline-none"
value={period} value={period}
onChange={(event) => setPeriod(event.target.value as PeriodKey)} onChange={(event) => setPeriod(event.target.value as PeriodKey)}
> >
@@ -561,7 +561,7 @@ export default function TierHistoryChart({
</ResponsiveContainer> </ResponsiveContainer>
</div> </div>
{summary && summaryVariant === "footer" && ( {summary && summaryVariant === "footer" && (
<div className="flex flex-wrap items-center gap-x-5 gap-y-1 border-t border-base-content/8 px-4 py-2.5 text-[11px]"> <div className="flex flex-wrap items-center gap-x-5 gap-y-1 border-t border-base-content/8 px-4 py-2.5 text-xs">
<span className="text-base-content/45"> <span className="text-base-content/45">
현재{" "} 현재{" "}
<span className="font-bold text-base-content/75"> <span className="font-bold text-base-content/75">
+97 -2
View File
@@ -29,8 +29,97 @@ body {
"Segoe UI Emoji", "Segoe UI Emoji",
"Segoe UI Symbol", "Segoe UI Symbol",
sans-serif; sans-serif;
font-size: 14px; font-size: 15px;
line-height: 1.5; line-height: 1.55;
}
/* ── 가독성 개선: 의미 기반 텍스트 대비 토큰 ──
폰트 크기는 표준 스케일 토큰(text-xs=12px / text-sm=14px …)을 사용한다.
새 코드에서는 text-content-subtle/muted/disabled를 우선 사용한다. */
:root,
[data-theme="light"] {
--lts-text-subtle-strength: 66%;
--lts-text-muted-strength: 72%;
--lts-text-disabled-strength: 50%;
--lts-content-subtle: color-mix(
in oklab,
var(--color-base-content) var(--lts-text-subtle-strength),
transparent
);
--lts-content-muted: color-mix(
in oklab,
var(--color-base-content) var(--lts-text-muted-strength),
transparent
);
--lts-content-disabled: color-mix(
in oklab,
var(--color-base-content) var(--lts-text-disabled-strength),
transparent
);
}
[data-theme="dark"] {
--lts-text-subtle-strength: 66%;
--lts-text-muted-strength: 76%;
--lts-text-disabled-strength: 52%;
}
@theme inline {
--color-content-subtle: var(--lts-content-subtle);
--color-content-muted: var(--lts-content-muted);
--color-content-disabled: var(--lts-content-disabled);
}
@layer utilities {
/* 기존 text-base-content/nn 알파 클래스 호환 shim.
hover/focus 상태 유틸이 specificity로 이길 수 있도록 !important를 쓰지 않는다. */
.text-base-content\/15,
.text-base-content\/20,
.text-base-content\/25,
.text-base-content\/30,
.text-base-content\/35 {
color: var(--lts-content-subtle);
}
.text-base-content\/40,
.text-base-content\/45,
.text-base-content\/50,
.text-base-content\/55 {
color: var(--lts-content-muted);
}
}
/* ════════════════════════════════════════════════════════════
🎛️ 튜닝 패널 (실험용) — 값만 바꾸면 dev에서 즉시 반영(HMR).
확정되면 element로 전환한 뒤 이 블록을 통째로 제거할 것.
색은 oklch(밝기% 채도 색상) 형식.
════════════════════════════════════════════════════════════ */
[data-theme="light"] {
/* ── 포인트 4색 (primary 주 액션 / secondary 강조 / accent 하이라이트 / info 정보·보조) ── */
/* 코랄레드 — primary 117곳 즉시 반영 */
--color-primary: oklch(0.708008 0.234375 24);
--color-primary-content: oklch(98% 0 0); /* 흰 글자 */
/* 바이올렛 — 버튼·뱃지·보더용 */
--color-secondary: oklch(0.481934 0.285938 285);
--color-secondary-content: oklch(98% 0 0); /* 흰 글자 */
/* 골드 — 배경·보더·아이콘만. 텍스트색(text-accent)으론 쓰지 말 것 */
--color-accent: oklch(0.853027 0.2 90);
--color-accent-content: oklch(22% 0.03 80); /* 어두운 글자 */
/* 시안 — 정보·링크·보조 강조. L70이라 흰배경 텍스트는 약함 → 배경/보더 위주 */
--color-info: oklch(70% 0.14523 200);
--color-info-content: oklch(24% 0.03 215); /* 어두운 글자 */
/* 텍스트 기본 진하기 (회색 알파의 기준색). 낮출수록 전체가 진해짐 */
--color-base-content: oklch(21% 0.006 285.885);
/* 표면 톤 */
--color-base-100: oklch(100% 0 0); /* 페이지/카드 배경 */
--color-base-200: oklch(98% 0 0); /* 살짝 들어간 표면 */
--color-base-300: oklch(95% 0 0); /* 구분선/보더 */
} }
/* poro.gg style: 모든 모서리 각지게 */ /* poro.gg style: 모든 모서리 각지게 */
@@ -49,3 +138,9 @@ body {
.btn { .btn {
border-radius: 0 !important; border-radius: 0 !important;
} }
/* daisyUI 버튼의 흰색 inset 하이라이트 제거 — 색 위에 흰색을 6% 얹어
채도를 깎던 주범(P3/쨍한 색일수록 도드라짐). drop shadow(입체감)는 유지. */
.btn {
box-shadow: var(--btn-shadow) !important;
}
+56 -56
View File
@@ -136,7 +136,7 @@ const POSITION_TO_RIOT_LANE = {
function PosBadge({ pos }: { pos: Position }) { function PosBadge({ pos }: { pos: Position }) {
return ( return (
<span className="inline-flex items-center gap-1.5 text-[11px] font-medium px-1.5 py-0.5 border border-primary/20 text-primary bg-primary/5"> <span className="inline-flex items-center gap-1.5 text-xs font-medium px-1.5 py-0.5 border border-primary/20 text-primary bg-primary/5">
<img src={positionIcon[pos]} alt="" className="w-3.5 h-3.5 object-contain" /> <img src={positionIcon[pos]} alt="" className="w-3.5 h-3.5 object-contain" />
<span>{positionLabel[pos]}</span> <span>{positionLabel[pos]}</span>
</span> </span>
@@ -182,10 +182,10 @@ function RecentSoloStats({
if (!primaryStats) { if (!primaryStats) {
return ( return (
<div className="p-4"> <div className="p-4">
<h4 className="text-[10px] font-bold uppercase tracking-wider text-base-content/30 mb-2.5"> <h4 className="text-xs font-bold uppercase tracking-wider text-base-content/30 mb-2.5">
최근 솔로랭크 최근 솔로랭크
</h4> </h4>
<div className="rounded border border-dashed border-base-content/10 px-3 py-6 text-center text-[11px] text-base-content/25"> <div className="rounded border border-dashed border-base-content/10 px-3 py-6 text-center text-xs text-base-content/25">
최근 솔로랭크 기록이 없습니다 최근 솔로랭크 기록이 없습니다
</div> </div>
</div> </div>
@@ -199,15 +199,15 @@ function RecentSoloStats({
<div className="p-4"> <div className="p-4">
<div className="flex items-start justify-between gap-3 mb-3"> <div className="flex items-start justify-between gap-3 mb-3">
<div> <div>
<h4 className="text-[10px] font-bold uppercase tracking-wider text-base-content/30"> <h4 className="text-xs font-bold uppercase tracking-wider text-base-content/30">
최근 솔로랭크 최근 솔로랭크
</h4> </h4>
<div className="mt-1 flex items-center gap-2"> <div className="mt-1 flex items-center gap-2">
<span className="text-[12px] font-semibold text-base-content"> <span className="text-xs font-semibold text-base-content">
{positionLabel[player.mainPosition]} {positionLabel[player.mainPosition]}
</span> </span>
{player.recentStats.primarySource === 'overall' ? ( {player.recentStats.primarySource === 'overall' ? (
<span className="text-[10px] text-base-content/35"> <span className="text-xs text-base-content/35">
전체 기준 전체 기준
</span> </span>
) : null} ) : null}
@@ -222,15 +222,15 @@ function RecentSoloStats({
<div className="space-y-2"> <div className="space-y-2">
<div className="flex items-baseline justify-between"> <div className="flex items-baseline justify-between">
<span className="text-[11px] text-base-content/40">전적</span> <span className="text-xs text-base-content/40">전적</span>
<span className="text-[12px] text-base-content/60 tabular-nums"> <span className="text-xs text-base-content/60 tabular-nums">
<span className="text-blue-400">{primaryStats.wins}W</span>{' '} <span className="text-blue-400">{primaryStats.wins}W</span>{' '}
<span className="text-red-400">{primaryStats.losses}L</span> <span className="text-red-400">{primaryStats.losses}L</span>
</span> </span>
</div> </div>
<div className="flex items-baseline justify-between"> <div className="flex items-baseline justify-between">
<span className="text-[11px] text-base-content/40">KDA</span> <span className="text-xs text-base-content/40">KDA</span>
<span className="text-[12px] text-base-content/60 tabular-nums"> <span className="text-xs text-base-content/60 tabular-nums">
{primaryStats.avgKills}/{primaryStats.avgDeaths}/{primaryStats.avgAssists} {primaryStats.avgKills}/{primaryStats.avgDeaths}/{primaryStats.avgAssists}
<span <span
className={`ml-1 font-bold ${Number(primaryKdaRatio) >= 3 ? 'text-emerald-400' : 'text-base-content/50'}`} className={`ml-1 font-bold ${Number(primaryKdaRatio) >= 3 ? 'text-emerald-400' : 'text-base-content/50'}`}
@@ -240,8 +240,8 @@ function RecentSoloStats({
</span> </span>
</div> </div>
<div className="flex items-baseline justify-between"> <div className="flex items-baseline justify-between">
<span className="text-[11px] text-base-content/40">분당 CS</span> <span className="text-xs text-base-content/40">분당 CS</span>
<span className="text-[12px] text-base-content/60 tabular-nums"> <span className="text-xs text-base-content/60 tabular-nums">
{primaryStats.avgCsPerMin} {primaryStats.avgCsPerMin}
</span> </span>
</div> </div>
@@ -256,7 +256,7 @@ function RecentSoloStats({
return ( return (
<div <div
key={position} key={position}
className={`flex items-center justify-between gap-3 text-[11px] ${isMainLane ? 'font-semibold text-base-content' : 'text-base-content/65'}`} className={`flex items-center justify-between gap-3 text-xs ${isMainLane ? 'font-semibold text-base-content' : 'text-base-content/65'}`}
> >
<span className={isMainLane ? 'text-base-content' : 'text-base-content/35'}> <span className={isMainLane ? 'text-base-content' : 'text-base-content/35'}>
{positionLabel[position]} {positionLabel[position]}
@@ -304,10 +304,10 @@ function TeamPanel({
<div className={`${tone.bg} px-3 py-2 border-b ${tone.border}`}> <div className={`${tone.bg} px-3 py-2 border-b ${tone.border}`}>
<div className="flex items-center justify-between"> <div className="flex items-center justify-between">
<div className="flex items-center gap-2"> <div className="flex items-center gap-2">
<span className={`text-[11px] font-bold uppercase tracking-wide ${tone.text}`}> <span className={`text-xs font-bold uppercase tracking-wide ${tone.text}`}>
{teamIndexLabel(team.teamIndex, team.name)} {teamIndexLabel(team.teamIndex, team.name)}
</span> </span>
<span className="text-[10px] text-base-content/30"> <span className="text-xs text-base-content/30">
팀장: {team.captainName} 팀장: {team.captainName}
</span> </span>
</div> </div>
@@ -315,7 +315,7 @@ function TeamPanel({
{formatPoints(team.points)}P {formatPoints(team.points)}P
</span> </span>
</div> </div>
<div className="mt-1 flex items-center justify-between text-[10px]"> <div className="mt-1 flex items-center justify-between text-xs">
<span className="text-base-content/25"> <span className="text-base-content/25">
팀장 포함 {teamSize}/{AUCTION_MAX_TEAM_SIZE} 팀장 포함 {teamSize}/{AUCTION_MAX_TEAM_SIZE}
</span> </span>
@@ -325,7 +325,7 @@ function TeamPanel({
<div className="divide-y divide-base-content/5"> <div className="divide-y divide-base-content/5">
{team.members.length === 0 ? ( {team.members.length === 0 ? (
<div className="px-3 py-6 text-center text-[11px] text-base-content/20"> <div className="px-3 py-6 text-center text-xs text-base-content/20">
아직 멤버가 없습니다 아직 멤버가 없습니다
</div> </div>
) : ( ) : (
@@ -349,15 +349,15 @@ function TeamPanel({
</div> </div>
<RankBadge tier={member.tier} /> <RankBadge tier={member.tier} />
<div className="flex-1 min-w-0"> <div className="flex-1 min-w-0">
<span className="text-[12px] font-medium text-base-content truncate block leading-tight group-hover:text-primary transition-colors"> <span className="text-xs font-medium text-base-content truncate block leading-tight group-hover:text-primary transition-colors">
{member.summonerName} {member.summonerName}
</span> </span>
</div> </div>
</Link> </Link>
<span className="shrink-0 text-[11px] font-semibold text-base-content/45"> <span className="shrink-0 text-xs font-semibold text-base-content/45">
{positionLabel[member.assignedPosition]} {positionLabel[member.assignedPosition]}
</span> </span>
<span className="text-[10px] text-amber-400/60 tabular-nums w-8 text-right"> <span className="text-xs text-amber-400/60 tabular-nums w-8 text-right">
{member.cost} {member.cost}
</span> </span>
</div> </div>
@@ -372,7 +372,7 @@ function TeamPanel({
className="px-3 py-1.5 h-[34px] flex items-center" className="px-3 py-1.5 h-[34px] flex items-center"
> >
<div className="w-6 h-6 border border-dashed border-base-content/8 shrink-0" /> <div className="w-6 h-6 border border-dashed border-base-content/8 shrink-0" />
<span className="ml-2 text-[10px] text-base-content/10">—</span> <span className="ml-2 text-xs text-base-content/10">—</span>
</div> </div>
))} ))}
</div> </div>
@@ -424,16 +424,16 @@ function PlayerSpotlight({
> >
{player.summonerName} {player.summonerName}
</Link> </Link>
<span className="text-[10px] text-base-content/25"> <span className="text-xs text-base-content/25">
#{player.tag} #{player.tag}
</span> </span>
</div> </div>
<div className="mb-2 text-[11px]"> <div className="mb-2 text-xs">
<ResponsiveTierLabel tier={player.tier} /> <ResponsiveTierLabel tier={player.tier} />
</div> </div>
<div className="flex items-center gap-1.5"> <div className="flex items-center gap-1.5">
<PosBadge pos={player.mainPosition} /> <PosBadge pos={player.mainPosition} />
<span className="inline-flex items-center gap-0.5 text-[11px] px-1.5 py-0.5 border border-base-content/8 text-base-content/35"> <span className="inline-flex items-center gap-0.5 text-xs px-1.5 py-0.5 border border-base-content/8 text-base-content/35">
<img <img
src={positionIcon[player.subPosition]} src={positionIcon[player.subPosition]}
alt="" alt=""
@@ -464,7 +464,7 @@ function PlayerSpotlight({
<div className="grid grid-cols-2 divide-x divide-base-content/5"> <div className="grid grid-cols-2 divide-x divide-base-content/5">
<div className="p-4"> <div className="p-4">
<h4 className="text-[10px] font-bold uppercase tracking-wider text-base-content/30 mb-2.5"> <h4 className="text-xs font-bold uppercase tracking-wider text-base-content/30 mb-2.5">
숙련도 높은 챔피언 숙련도 높은 챔피언
</h4> </h4>
<div className="space-y-2"> <div className="space-y-2">
@@ -487,10 +487,10 @@ function PlayerSpotlight({
) : null} ) : null}
</div> </div>
<div className="flex-1 min-w-0"> <div className="flex-1 min-w-0">
<div className="text-[12px] font-medium text-base-content truncate"> <div className="text-xs font-medium text-base-content truncate">
{displayName} {displayName}
</div> </div>
<div className="text-[10px] text-base-content/25"> <div className="text-xs text-base-content/25">
Lv.{mastery.level} · {(mastery.points / 1000).toFixed(0)}K Lv.{mastery.level} · {(mastery.points / 1000).toFixed(0)}K
</div> </div>
</div> </div>
@@ -498,7 +498,7 @@ function PlayerSpotlight({
); );
}) })
) : ( ) : (
<div className="text-[11px] text-base-content/25"> <div className="text-xs text-base-content/25">
숙련도 데이터가 없습니다. 숙련도 데이터가 없습니다.
</div> </div>
)} )}
@@ -511,13 +511,13 @@ function PlayerSpotlight({
{(state.phase === 'bidding' || state.phase === 'sold') && ( {(state.phase === 'bidding' || state.phase === 'sold') && (
<div className="border-t border-base-content/8 px-4 py-3 bg-base-content/[0.02]"> <div className="border-t border-base-content/8 px-4 py-3 bg-base-content/[0.02]">
<div className="flex items-center justify-between"> <div className="flex items-center justify-between">
<span className="text-[11px] text-base-content/30 uppercase tracking-wider font-semibold"> <span className="text-xs text-base-content/30 uppercase tracking-wider font-semibold">
{state.phase === 'sold' ? '낙찰가' : '현재 입찰가'} {state.phase === 'sold' ? '낙찰가' : '현재 입찰가'}
</span> </span>
<div className="flex items-center gap-2"> <div className="flex items-center gap-2">
{state.currentBidder && ( {state.currentBidder && (
<span <span
className={`text-[10px] font-bold uppercase ${teamIndexColorClasses(state.currentBidder.teamIndex).text}`} className={`text-xs font-bold uppercase ${teamIndexColorClasses(state.currentBidder.teamIndex).text}`}
> >
{teamIndexLabel(state.currentBidder.teamIndex)} {teamIndexLabel(state.currentBidder.teamIndex)}
</span> </span>
@@ -584,7 +584,7 @@ function BidControls({
key={preset} key={preset}
onClick={() => setBidAmount(Math.max(minBid, preset))} onClick={() => setBidAmount(Math.max(minBid, preset))}
disabled={isActiveTeamFull} disabled={isActiveTeamFull}
className={`text-[11px] px-2.5 py-1 border transition-colors ${ className={`text-xs px-2.5 py-1 border transition-colors ${
bidAmount === preset bidAmount === preset
? 'border-primary/40 bg-primary/10 text-primary' ? 'border-primary/40 bg-primary/10 text-primary'
: 'border-base-content/10 text-base-content/40 hover:border-base-content/20' : 'border-base-content/10 text-base-content/40 hover:border-base-content/20'
@@ -635,13 +635,13 @@ function BidLog({ bids }: { bids: AuctionStateView['bids'] }) {
return ( return (
<div className="border border-base-content/10 bg-base-100 overflow-hidden"> <div className="border border-base-content/10 bg-base-100 overflow-hidden">
<div className="px-3 py-1.5 border-b border-base-content/8 bg-base-200/40"> <div className="px-3 py-1.5 border-b border-base-content/8 bg-base-200/40">
<span className="text-[10px] font-bold uppercase tracking-wider text-base-content/30"> <span className="text-xs font-bold uppercase tracking-wider text-base-content/30">
입찰 기록 입찰 기록
</span> </span>
</div> </div>
<div className="max-h-28 overflow-y-auto p-2 space-y-0.5"> <div className="max-h-28 overflow-y-auto p-2 space-y-0.5">
{bids.map((bid, index) => ( {bids.map((bid, index) => (
<div key={`${bid.teamIndex}-${bid.timestamp}-${index}`} className="flex items-center gap-2 text-[11px]"> <div key={`${bid.teamIndex}-${bid.timestamp}-${index}`} className="flex items-center gap-2 text-xs">
<span <span
className={`font-bold uppercase ${teamIndexColorClasses(bid.teamIndex).text}`} className={`font-bold uppercase ${teamIndexColorClasses(bid.teamIndex).text}`}
> >
@@ -846,10 +846,10 @@ export default function AuctionPage() {
const undoPanel = canManageAuction ? ( const undoPanel = canManageAuction ? (
<div className="border border-base-content/10 bg-base-100 p-4 space-y-3"> <div className="border border-base-content/10 bg-base-100 p-4 space-y-3">
<div className="text-[10px] font-bold uppercase tracking-wider text-base-content/35"> <div className="text-xs font-bold uppercase tracking-wider text-base-content/35">
되돌리기 (Undo) 되돌리기 (Undo)
</div> </div>
<div className="max-h-48 overflow-y-auto space-y-1 text-[11px]"> <div className="max-h-48 overflow-y-auto space-y-1 text-xs">
{historyQuery.data?.length ? ( {historyQuery.data?.length ? (
historyQuery.data.map((entry) => ( historyQuery.data.map((entry) => (
<button <button
@@ -863,7 +863,7 @@ export default function AuctionPage() {
#{entry.sequence} #{entry.sequence}
</span> </span>
<span className="text-base-content/45">{entry.actionLabel}</span> <span className="text-base-content/45">{entry.actionLabel}</span>
<span className="text-[10px] text-base-content/25"> <span className="text-xs text-base-content/25">
{relativeTime(entry.takenAt)} {relativeTime(entry.takenAt)}
</span> </span>
</button> </button>
@@ -923,7 +923,7 @@ export default function AuctionPage() {
<h1 className="text-xl font-bold text-base-content leading-tight"> <h1 className="text-xl font-bold text-base-content leading-tight">
경매 팀빌딩 경매 팀빌딩
</h1> </h1>
<p className="text-[11px] text-base-content/30 mt-0.5"> <p className="text-xs text-base-content/30 mt-0.5">
{Math.min(auctionState.currentPlayerIndex + 1, Math.max(auctionState.totalPlayers, 1))} /{' '} {Math.min(auctionState.currentPlayerIndex + 1, Math.max(auctionState.totalPlayers, 1))} /{' '}
{auctionState.totalPlayers} 선수 {auctionState.totalPlayers} 선수
</p> </p>
@@ -931,7 +931,7 @@ export default function AuctionPage() {
<div className="flex flex-col items-end gap-2"> <div className="flex flex-col items-end gap-2">
<div className="flex items-center gap-2"> <div className="flex items-center gap-2">
<span <span
className={`inline-flex items-center text-[11px] font-semibold px-2 py-1 border ${ className={`inline-flex items-center text-xs font-semibold px-2 py-1 border ${
auctionState.phase === 'bidding' auctionState.phase === 'bidding'
? 'border-green-500/20 bg-green-500/10 text-green-400' ? 'border-green-500/20 bg-green-500/10 text-green-400'
: auctionState.phase === 'sold' : auctionState.phase === 'sold'
@@ -1009,7 +1009,7 @@ export default function AuctionPage() {
</div> </div>
<Link <Link
to={`/match/${id}`} to={`/match/${id}`}
className="btn btn-primary btn-sm mt-4 px-6 text-[11px]" className="btn btn-primary btn-sm mt-4 px-6 text-xs"
> >
결과 확인 결과 확인
</Link> </Link>
@@ -1045,7 +1045,7 @@ export default function AuctionPage() {
{canManageAuction && ( {canManageAuction && (
<div className="border border-base-content/10 bg-base-100 p-4 space-y-3"> <div className="border border-base-content/10 bg-base-100 p-4 space-y-3">
<div className="text-[10px] font-bold uppercase tracking-wider text-base-content/35"> <div className="text-xs font-bold uppercase tracking-wider text-base-content/35">
Auction Controls Auction Controls
</div> </div>
{auctionState.phase === 'presenting' && ( {auctionState.phase === 'presenting' && (
@@ -1102,7 +1102,7 @@ export default function AuctionPage() {
<AlertTriangle className="h-3.5 w-3.5" /> <AlertTriangle className="h-3.5 w-3.5" />
경매 진행 취소 경매 진행 취소
</button> </button>
<p className="mt-2 text-[11px] leading-relaxed text-base-content/35"> <p className="mt-2 text-xs leading-relaxed text-base-content/35">
경매 데이터와 진행 기록을 삭제하고 내전을 모집 상태로 되돌립니다. 경매 데이터와 진행 기록을 삭제하고 내전을 모집 상태로 되돌립니다.
</p> </p>
</div> </div>
@@ -1172,7 +1172,7 @@ export default function AuctionPage() {
<label <label
htmlFor="auction-cancel-confirm" htmlFor="auction-cancel-confirm"
className="mt-5 block text-[11px] font-bold uppercase tracking-wider text-base-content/40" className="mt-5 block text-xs font-bold uppercase tracking-wider text-base-content/40"
> >
계속하려면 예 입력 계속하려면 예 입력
</label> </label>
@@ -1291,7 +1291,7 @@ function PoolPanel({ state }: { state: AuctionStateView }) {
<div className="flex-1 overflow-y-auto"> <div className="flex-1 overflow-y-auto">
{activePool.length === 0 ? ( {activePool.length === 0 ? (
<div className="px-3 py-8 text-center text-[11px] text-base-content/30"> <div className="px-3 py-8 text-center text-xs text-base-content/30">
{tab === 'waiting' {tab === 'waiting'
? '대기 중인 유저가 없습니다' ? '대기 중인 유저가 없습니다'
: '유찰된 유저가 없습니다'} : '유찰된 유저가 없습니다'}
@@ -1329,14 +1329,14 @@ function PoolTabButton({
role="tab" role="tab"
type="button" type="button"
onClick={onClick} onClick={onClick}
className={`relative px-1 pt-3 pb-2.5 mr-5 text-[12px] font-semibold transition-colors ${ className={`relative px-1 pt-3 pb-2.5 mr-5 text-xs font-semibold transition-colors ${
active active
? 'text-base-content' ? 'text-base-content'
: 'text-base-content/40 hover:text-base-content/70' : 'text-base-content/40 hover:text-base-content/70'
}`} }`}
> >
{label} {label}
<span className="ml-1 text-[10px] tabular-nums text-base-content/30"> <span className="ml-1 text-xs tabular-nums text-base-content/30">
{count} {count}
</span> </span>
{active ? ( {active ? (
@@ -1363,12 +1363,12 @@ function PoolListItem({
className="w-7 h-7 shrink-0 rounded-sm border border-base-content/10 object-cover" className="w-7 h-7 shrink-0 rounded-sm border border-base-content/10 object-cover"
/> />
<div className="min-w-0 flex-1 flex items-center gap-1.5"> <div className="min-w-0 flex-1 flex items-center gap-1.5">
<span className="truncate text-[12px] font-semibold text-base-content"> <span className="truncate text-xs font-semibold text-base-content">
{player.summonerName} {player.summonerName}
</span> </span>
<RankBadge tier={player.tier} /> <RankBadge tier={player.tier} />
{showPassCount && player.passCount > 0 ? ( {showPassCount && player.passCount > 0 ? (
<span className="inline-flex items-center text-[10px] font-medium px-1.5 py-0.5 border border-amber-500/30 text-amber-500 bg-amber-500/5"> <span className="inline-flex items-center text-xs font-medium px-1.5 py-0.5 border border-amber-500/30 text-amber-500 bg-amber-500/5">
{player.passCount}회 유찰 {player.passCount}회 유찰
</span> </span>
) : null} ) : null}
@@ -1427,11 +1427,11 @@ function ChatPanel({
className={`border border-base-content/10 bg-base-100 flex min-h-0 flex-col ${className}`} className={`border border-base-content/10 bg-base-100 flex min-h-0 flex-col ${className}`}
> >
<div className="border-b border-base-content/10 px-3 py-2.5 flex items-center justify-between"> <div className="border-b border-base-content/10 px-3 py-2.5 flex items-center justify-between">
<div className="text-[10px] font-bold uppercase tracking-wider text-base-content/35"> <div className="text-xs font-bold uppercase tracking-wider text-base-content/35">
채팅 채팅
</div> </div>
<span <span
className={`text-[10px] ${ className={`text-xs ${
isConnected ? 'text-green-500' : 'text-base-content/30' isConnected ? 'text-green-500' : 'text-base-content/30'
}`} }`}
> >
@@ -1441,7 +1441,7 @@ function ChatPanel({
<div className="flex-1 min-h-0 overflow-y-auto px-3 py-3"> <div className="flex-1 min-h-0 overflow-y-auto px-3 py-3">
{messages.length === 0 ? ( {messages.length === 0 ? (
<div className="flex h-full items-center justify-center text-center text-[11px] text-base-content/25"> <div className="flex h-full items-center justify-center text-center text-xs text-base-content/25">
아직 메시지가 없습니다 아직 메시지가 없습니다
</div> </div>
) : ( ) : (
@@ -1449,14 +1449,14 @@ function ChatPanel({
{messages.map((message) => ( {messages.map((message) => (
<li key={message.id} className="space-y-1"> <li key={message.id} className="space-y-1">
<div className="flex items-center justify-between gap-2"> <div className="flex items-center justify-between gap-2">
<span className="min-w-0 truncate text-[11px] font-bold text-base-content/70"> <span className="min-w-0 truncate text-xs font-bold text-base-content/70">
{message.displayName} {message.displayName}
</span> </span>
<time className="shrink-0 text-[10px] tabular-nums text-base-content/25"> <time className="shrink-0 text-xs tabular-nums text-base-content/25">
{formatChatTime(message.sentAt)} {formatChatTime(message.sentAt)}
</time> </time>
</div> </div>
<p className="whitespace-pre-wrap break-words border border-base-content/8 bg-base-content/[0.03] px-2.5 py-2 text-[12px] leading-relaxed text-base-content/75"> <p className="whitespace-pre-wrap break-words border border-base-content/8 bg-base-content/[0.03] px-2.5 py-2 text-xs leading-relaxed text-base-content/75">
{message.message} {message.message}
</p> </p>
</li> </li>
@@ -1467,7 +1467,7 @@ function ChatPanel({
</div> </div>
<form onSubmit={handleSubmit} className="border-t border-base-content/10 p-2 space-y-2"> <form onSubmit={handleSubmit} className="border-t border-base-content/10 p-2 space-y-2">
<div className="flex items-center justify-between gap-2 px-0.5 text-[10px] text-base-content/30"> <div className="flex items-center justify-between gap-2 px-0.5 text-xs text-base-content/30">
<span className="truncate">{senderLabel}</span> <span className="truncate">{senderLabel}</span>
<span className="tabular-nums">{draft.length}/300</span> <span className="tabular-nums">{draft.length}/300</span>
</div> </div>
@@ -1478,14 +1478,14 @@ function ChatPanel({
disabled={!isConnected} disabled={!isConnected}
maxLength={300} maxLength={300}
placeholder="메시지를 입력하세요" placeholder="메시지를 입력하세요"
className="w-full resize-none border border-base-content/10 bg-base-content/5 px-2 py-1.5 text-[12px] text-base-content/80 placeholder:text-base-content/25 focus:border-primary/40 focus:outline-none disabled:cursor-not-allowed disabled:text-base-content/30" className="w-full resize-none border border-base-content/10 bg-base-content/5 px-2 py-1.5 text-xs text-base-content/80 placeholder:text-base-content/25 focus:border-primary/40 focus:outline-none disabled:cursor-not-allowed disabled:text-base-content/30"
rows={2} rows={2}
aria-label="경매 채팅 메시지" aria-label="경매 채팅 메시지"
/> />
<button <button
type="submit" type="submit"
disabled={!canSend} disabled={!canSend}
className="btn btn-primary btn-sm w-full text-[11px]" className="btn btn-primary btn-sm w-full text-xs"
> >
<SendHorizontal className="h-3.5 w-3.5" aria-hidden="true" /> <SendHorizontal className="h-3.5 w-3.5" aria-hidden="true" />
전송 전송
@@ -86,7 +86,7 @@ function MatchCard({
<article className="border border-base-content/10 bg-base-100 hover:border-primary/25 transition-colors"> <article className="border border-base-content/10 bg-base-100 hover:border-primary/25 transition-colors">
<div className="p-4 grid lg:grid-cols-[1fr_auto_1fr] gap-4 items-center"> <div className="p-4 grid lg:grid-cols-[1fr_auto_1fr] gap-4 items-center">
<div className="min-w-0"> <div className="min-w-0">
<div className="text-[11px] text-base-content/35"> <div className="text-xs text-base-content/35">
{formatDateTime(match.scheduledAt)} {formatDateTime(match.scheduledAt)}
</div> </div>
<h3 className="mt-1 text-base font-black text-base-content truncate group-hover:text-primary"> <h3 className="mt-1 text-base font-black text-base-content truncate group-hover:text-primary">
@@ -96,7 +96,7 @@ function MatchCard({
{match.games.map((game) => ( {match.games.map((game) => (
<span <span
key={game.gameNumber} key={game.gameNumber}
className="inline-flex items-center gap-1 border border-base-content/10 px-2 py-1 text-[10px] text-base-content/45" className="inline-flex items-center gap-1 border border-base-content/10 px-2 py-1 text-xs text-base-content/45"
> >
{game.gameNumber}경기 {game.gameNumber}경기
{game.winnerSide && game.winnerTeamIndex ? ( {game.winnerSide && game.winnerTeamIndex ? (
@@ -117,14 +117,14 @@ function MatchCard({
<div className="flex items-center justify-center gap-5"> <div className="flex items-center justify-center gap-5">
<div className={primarySeries.winnerTeamIndex === primarySeries.teamAIndex ? teamIndexColorClasses(primarySeries.teamAIndex).text : 'text-base-content/30'}> <div className={primarySeries.winnerTeamIndex === primarySeries.teamAIndex ? teamIndexColorClasses(primarySeries.teamAIndex).text : 'text-base-content/30'}>
<div className="text-4xl font-black tabular-nums">{primarySeries.teamAWins}</div> <div className="text-4xl font-black tabular-nums">{primarySeries.teamAWins}</div>
<div className="text-[10px] font-bold uppercase tracking-wider"> <div className="text-xs font-bold uppercase tracking-wider">
{teamName(primarySeries.teamAIndex)} {teamName(primarySeries.teamAIndex)}
</div> </div>
</div> </div>
<div className="text-base-content/15 text-xs font-black">VS</div> <div className="text-base-content/15 text-xs font-black">VS</div>
<div className={primarySeries.winnerTeamIndex === primarySeries.teamBIndex ? teamIndexColorClasses(primarySeries.teamBIndex).text : 'text-base-content/30'}> <div className={primarySeries.winnerTeamIndex === primarySeries.teamBIndex ? teamIndexColorClasses(primarySeries.teamBIndex).text : 'text-base-content/30'}>
<div className="text-4xl font-black tabular-nums">{primarySeries.teamBWins}</div> <div className="text-4xl font-black tabular-nums">{primarySeries.teamBWins}</div>
<div className="text-[10px] font-bold uppercase tracking-wider"> <div className="text-xs font-bold uppercase tracking-wider">
{teamName(primarySeries.teamBIndex)} {teamName(primarySeries.teamBIndex)}
</div> </div>
</div> </div>
@@ -138,7 +138,7 @@ function MatchCard({
key={team.teamIndex} key={team.teamIndex}
className={`border ${teamIndexColorClasses(team.teamIndex).border} p-2`} className={`border ${teamIndexColorClasses(team.teamIndex).border} p-2`}
> >
<div className={`text-[10px] font-black uppercase tracking-wider ${teamIndexColorClasses(team.teamIndex).text}`}> <div className={`text-xs font-black uppercase tracking-wider ${teamIndexColorClasses(team.teamIndex).text}`}>
{team.name} {team.name}
</div> </div>
<div className="mt-2 space-y-1"> <div className="mt-2 space-y-1">
@@ -152,7 +152,7 @@ function MatchCard({
loading="lazy" loading="lazy"
/> />
</span> </span>
<span className="text-[11px] truncate text-base-content/65"> <span className="text-xs truncate text-base-content/65">
{member.summonerName} {member.summonerName}
</span> </span>
</div> </div>
@@ -178,13 +178,13 @@ function HighlightCard({
}) { }) {
return ( return (
<div className="border border-base-content/10 bg-base-100 p-4"> <div className="border border-base-content/10 bg-base-100 p-4">
<div className="text-[10px] font-black uppercase tracking-wider text-base-content/30"> <div className="text-xs font-black uppercase tracking-wider text-base-content/30">
{title} {title}
</div> </div>
<div className="mt-2 text-xl font-black text-base-content tabular-nums"> <div className="mt-2 text-xl font-black text-base-content tabular-nums">
{highlight ? `${highlight.metric}${suffix}` : '-'} {highlight ? `${highlight.metric}${suffix}` : '-'}
</div> </div>
<div className="mt-1 text-[12px] text-base-content/45"> <div className="mt-1 text-xs text-base-content/45">
{highlight?.summonerName ?? '기록 없음'} {highlight?.summonerName ?? '기록 없음'}
</div> </div>
</div> </div>
@@ -206,7 +206,7 @@ function LeaderboardTable({
<div className="overflow-x-auto"> <div className="overflow-x-auto">
<table className="w-full text-left min-w-[920px]"> <table className="w-full text-left min-w-[920px]">
<thead> <thead>
<tr className="border-b border-base-content/10 bg-base-200/50 text-[11px] uppercase tracking-wider text-base-content/35"> <tr className="border-b border-base-content/10 bg-base-200/50 text-xs uppercase tracking-wider text-base-content/35">
<th className="px-3 py-2.5">#</th> <th className="px-3 py-2.5">#</th>
<th className="px-3 py-2.5">소환사</th> <th className="px-3 py-2.5">소환사</th>
<th className="px-3 py-2.5 text-center">승률</th> <th className="px-3 py-2.5 text-center">승률</th>
@@ -221,7 +221,7 @@ function LeaderboardTable({
<tbody> <tbody>
{rows.map((row, index) => ( {rows.map((row, index) => (
<tr key={row.userId} className="border-b border-base-content/5 last:border-b-0"> <tr key={row.userId} className="border-b border-base-content/5 last:border-b-0">
<td className="px-3 py-2.5 text-[11px] text-base-content/30"> <td className="px-3 py-2.5 text-xs text-base-content/30">
{index + 1} {index + 1}
</td> </td>
<td className="px-3 py-2.5"> <td className="px-3 py-2.5">
@@ -238,31 +238,31 @@ function LeaderboardTable({
loading="lazy" loading="lazy"
/> />
</span> </span>
<span className="font-bold text-[13px] group-hover:text-primary"> <span className="font-bold text-sm group-hover:text-primary">
{row.summonerName} {row.summonerName}
</span> </span>
</Link> </Link>
</td> </td>
<td className={`px-3 py-2.5 text-center text-[13px] font-black ${ratioClass(row.winRate)}`}> <td className={`px-3 py-2.5 text-center text-sm font-black ${ratioClass(row.winRate)}`}>
{row.winRate}% {row.winRate}%
</td> </td>
<td className="px-3 py-2.5 text-center text-[12px] tabular-nums"> <td className="px-3 py-2.5 text-center text-xs tabular-nums">
{row.games} {row.games}
</td> </td>
<td className="px-3 py-2.5 text-center text-[12px] font-bold tabular-nums"> <td className="px-3 py-2.5 text-center text-xs font-bold tabular-nums">
{row.kda} {row.kda}
</td> </td>
<td className="px-3 py-2.5 text-center text-[12px] tabular-nums"> <td className="px-3 py-2.5 text-center text-xs tabular-nums">
{row.avgGoldPerMin} {row.avgGoldPerMin}
</td> </td>
<td className="px-3 py-2.5 text-center text-[12px] tabular-nums"> <td className="px-3 py-2.5 text-center text-xs tabular-nums">
{row.avgKillParticipation}% {row.avgKillParticipation}%
</td> </td>
<td className="px-3 py-2.5 text-center text-[12px] tabular-nums"> <td className="px-3 py-2.5 text-center text-xs tabular-nums">
{row.avgCsPerMin} {row.avgCsPerMin}
</td> </td>
<td className="px-3 py-2.5"> <td className="px-3 py-2.5">
<div className="flex flex-wrap gap-2 text-[11px] text-base-content/55"> <div className="flex flex-wrap gap-2 text-xs text-base-content/55">
{row.topChampions.map((champion) => ( {row.topChampions.map((champion) => (
<ChampionChip <ChampionChip
key={champion.championId} key={champion.championId}
@@ -326,7 +326,7 @@ export default function CommunityInternalStatsPage() {
<section className="mt-5 mb-6 border border-base-content/10 bg-base-100 p-5"> <section className="mt-5 mb-6 border border-base-content/10 bg-base-100 p-5">
<div className="flex flex-col sm:flex-row sm:items-end sm:justify-between gap-4"> <div className="flex flex-col sm:flex-row sm:items-end sm:justify-between gap-4">
<div> <div>
<p className="text-[11px] font-black uppercase tracking-[0.24em] text-primary"> <p className="text-xs font-black uppercase tracking-[0.24em] text-primary">
Community Records Community Records
</p> </p>
<h1 className="mt-2 text-3xl font-black text-base-content"> <h1 className="mt-2 text-3xl font-black text-base-content">
@@ -337,7 +337,7 @@ export default function CommunityInternalStatsPage() {
</p> </p>
</div> </div>
<div className="border border-base-content/10 px-4 py-3 text-sm text-base-content/55"> <div className="border border-base-content/10 px-4 py-3 text-sm text-base-content/55">
<div className="text-[10px] uppercase tracking-wider text-base-content/30"> <div className="text-xs uppercase tracking-wider text-base-content/30">
시즌 시즌
</div> </div>
<div className="mt-1 font-bold">{season?.label ?? '현재 시즌'}</div> <div className="mt-1 font-bold">{season?.label ?? '현재 시즌'}</div>
@@ -356,7 +356,7 @@ export default function CommunityInternalStatsPage() {
<section className="mb-8"> <section className="mb-8">
<div className="flex items-center justify-between gap-3 mb-3"> <div className="flex items-center justify-between gap-3 mb-3">
<h2 className="text-sm font-black text-base-content">최근 내전</h2> <h2 className="text-sm font-black text-base-content">최근 내전</h2>
<div className="text-[11px] text-base-content/35"> <div className="text-xs text-base-content/35">
블루 승률 {insightsQuery.data?.sideWinRate.blue ?? 0}% · 레드 승률{' '} 블루 승률 {insightsQuery.data?.sideWinRate.blue ?? 0}% · 레드 승률{' '}
{insightsQuery.data?.sideWinRate.red ?? 0}% {insightsQuery.data?.sideWinRate.red ?? 0}%
</div> </div>
@@ -392,7 +392,7 @@ export default function CommunityInternalStatsPage() {
<section> <section>
<div className="flex items-center justify-between gap-3 mb-3"> <div className="flex items-center justify-between gap-3 mb-3">
<h2 className="text-sm font-black text-base-content">선수 순위</h2> <h2 className="text-sm font-black text-base-content">선수 순위</h2>
<div className="text-[11px] text-base-content/35"> <div className="text-xs text-base-content/35">
포지션은 Riot Match의 라인 정보를 기준으로 합니다. 포지션은 Riot Match의 라인 정보를 기준으로 합니다.
</div> </div>
</div> </div>
+494 -74
View File
@@ -1,10 +1,243 @@
import { useState } from 'react';
import { ChevronLeft, ChevronRight } from 'lucide-react';
import { Link } from 'react-router'; import { Link } from 'react-router';
import { mapApiMatchToMatchDetail } from '../api/mappers'; import { mapApiMatchToMatchDetail } from '../api/mappers';
import { useMatches, useMe } from '../api/hooks'; import { useMatches, useMatchesPage, useMe } from '../api/hooks';
import { DEFAULT_COMMUNITY_ID } from '../config'; import { DEFAULT_COMMUNITY_ID } from '../config';
const UPCOMING_GRID_MATCH_LIMIT = 3; const UPCOMING_GRID_MATCH_LIMIT = 3;
const UPCOMING_MATCH_LIST_LIMIT = UPCOMING_GRID_MATCH_LIMIT + 1; const UPCOMING_MATCH_LIST_LIMIT = UPCOMING_GRID_MATCH_LIMIT + 1;
const HISTORY_MATCH_PAGE_SIZE = 10;
const EMPTY_SCHEDULE_TEXT = '예정된 매치가 없습니다.';
const HISTORY_TABLE_ROW_CLASS =
'h-10 border-b border-base-content/5 last:border-b-0';
function SkeletonBlock({ className }: { className: string }) {
return (
<div
aria-hidden="true"
className={`animate-pulse bg-base-content/10 ${className}`}
/>
);
}
function SkeletonText({
children,
className = '',
skeletonClassName,
}: {
children: string;
className?: string;
skeletonClassName: string;
}) {
return (
<span className={`relative block ${className}`}>
<span className="invisible">{children}</span>
<span
aria-hidden="true"
className={`absolute left-0 top-1/2 -translate-y-1/2 animate-pulse bg-base-content/10 ${skeletonClassName}`}
/>
</span>
);
}
function SkeletonBadge({
children,
className,
}: {
children: string;
className: string;
}) {
return (
<span className={`relative ${className}`}>
<span className="invisible">{children}</span>
<span
aria-hidden="true"
className="absolute inset-0 animate-pulse bg-base-content/10"
/>
</span>
);
}
function HistoryTableColGroup() {
return (
<colgroup>
<col className="w-[156px]" />
<col />
<col className="w-[88px]" />
<col className="w-[132px]" />
<col className="w-[72px]" />
<col className="w-[116px]" />
</colgroup>
);
}
function HistoryTableHeader() {
return (
<thead>
<tr className="bg-base-200/60 border-b border-base-content/10 text-xs uppercase tracking-wider text-base-content/40">
<th className="py-2.5 px-4 font-semibold">날짜</th>
<th className="py-2.5 px-4 font-semibold">내전</th>
<th className="py-2.5 px-4 font-semibold">상태</th>
<th className="py-2.5 px-4 font-semibold">맵</th>
<th className="py-2.5 px-4 font-semibold">참가</th>
<th className="py-2.5 px-4 font-semibold">결과</th>
</tr>
</thead>
);
}
function HistoryRecordsSkeleton({ rows = 5 }: { rows?: number }) {
const historySkeletons = Array.from({ length: rows });
return (
<>
<div className="hidden md:block border border-base-content/10 overflow-x-auto">
<table className="w-full table-fixed text-left">
<HistoryTableColGroup />
<HistoryTableHeader />
<tbody>
{historySkeletons.map((_, index) => (
<tr
key={index}
className={HISTORY_TABLE_ROW_CLASS}
>
<td className="py-2.5 px-4 text-xs text-base-content/40 whitespace-nowrap">
<SkeletonText
skeletonClassName="h-[1em] w-20"
>
2026년 6월 8일 월
</SkeletonText>
</td>
<td className="py-2.5 px-4">
<SkeletonText
className="truncate text-sm font-medium"
skeletonClassName="h-[1em] w-36 max-w-full"
>
정기 내전
</SkeletonText>
</td>
<td className="py-2.5 px-4">
<SkeletonBadge className="inline-flex items-center whitespace-nowrap text-xs font-semibold px-1.5 py-0.5 border border-transparent">
팀빌딩
</SkeletonBadge>
</td>
<td className="py-2.5 px-4">
<SkeletonBadge className="inline-flex items-center whitespace-nowrap text-xs px-1.5 py-0.5 border border-transparent">
소환사의 협곡
</SkeletonBadge>
</td>
<td className="py-2.5 px-4 text-xs text-base-content/50 whitespace-nowrap">
<SkeletonText
skeletonClassName="h-[1em] w-8"
>
10명
</SkeletonText>
</td>
<td className="py-2.5 px-4 text-xs text-base-content/50 whitespace-nowrap">
<SkeletonText
className="truncate"
skeletonClassName="h-[1em] w-14"
>
1팀 승리
</SkeletonText>
</td>
</tr>
))}
</tbody>
</table>
</div>
<div className="md:hidden border border-base-content/10">
{historySkeletons.map((_, index) => (
<div
key={index}
className="border-b border-base-content/5 last:border-b-0 p-3"
>
<div className="flex items-start justify-between gap-3">
<div className="min-w-0 flex-1 space-y-2">
<SkeletonBlock className="h-3 w-28" />
<SkeletonBlock className="h-4 w-32" />
</div>
<SkeletonBlock className="h-5 w-12 shrink-0" />
</div>
<SkeletonBlock className="mt-2 h-3 w-40" />
</div>
))}
</div>
</>
);
}
function HomePageSkeleton() {
const upcomingSkeletons = Array.from({ length: UPCOMING_GRID_MATCH_LIMIT });
return (
<main
className="max-w-5xl mx-auto px-4 sm:px-6"
aria-busy="true"
aria-live="polite"
>
<span className="sr-only">매치 목록을 불러오는 중...</span>
<section className="pt-8 pb-6">
<div className="flex items-center justify-between gap-3 mb-3">
<SkeletonBlock className="h-3 w-20" />
<div className="flex items-center gap-3">
<SkeletonBlock className="h-3 w-16" />
<SkeletonBlock className="h-3 w-20" />
</div>
</div>
<div className="border border-base-content/10 bg-base-200/50">
<div className="p-5 sm:p-6">
<div className="flex flex-col sm:flex-row sm:items-start sm:justify-between gap-4">
<div className="space-y-3 flex-1">
<div className="flex items-center gap-2.5 flex-wrap">
<SkeletonBlock className="h-7 w-52 sm:w-64" />
<SkeletonBlock className="h-5 w-12" />
</div>
<div className="space-y-2">
<SkeletonBlock className="h-4 w-full max-w-xl" />
<SkeletonBlock className="h-4 w-4/5 max-w-lg" />
</div>
<div className="flex items-center gap-3 flex-wrap pt-1">
<SkeletonBlock className="h-3 w-24" />
<SkeletonBlock className="h-3 w-12" />
<SkeletonBlock className="h-5 w-16" />
</div>
</div>
<SkeletonBlock className="h-8 w-24 sm:shrink-0" />
</div>
</div>
</div>
</section>
<section className="pb-6">
<SkeletonBlock className="h-3 w-24 mb-3" />
<div className="grid grid-cols-1 sm:grid-cols-2 lg:grid-cols-3 gap-px bg-base-content/10 border border-base-content/10">
{upcomingSkeletons.map((_, index) => (
<div key={index} className="bg-base-100 h-full p-4 min-h-[122px]">
<div className="flex items-center justify-between mb-3 gap-3">
<SkeletonBlock className="h-4 w-28" />
<SkeletonBlock className="h-5 w-12 shrink-0" />
</div>
<div className="space-y-2">
<SkeletonBlock className="h-3 w-24" />
<SkeletonBlock className="h-3 w-12" />
</div>
<SkeletonBlock className="h-5 w-16 mt-3" />
</div>
))}
</div>
</section>
<section className="pb-12">
<SkeletonBlock className="h-3 w-24 mb-3" />
<HistoryRecordsSkeleton />
</section>
</main>
);
}
function StatusBadge({ status }: { status: string }) { function StatusBadge({ status }: { status: string }) {
const styles: Record<string, string> = { const styles: Record<string, string> = {
@@ -16,7 +249,7 @@ function StatusBadge({ status }: { status: string }) {
return ( return (
<span <span
className={`inline-flex items-center text-[11px] font-semibold px-1.5 py-0.5 border ${styles[status] ?? 'bg-base-content/10 text-base-content/50 border-base-content/10'}`} className={`inline-flex items-center whitespace-nowrap text-xs font-semibold px-1.5 py-0.5 border ${styles[status] ?? 'bg-base-content/10 text-base-content/50 border-base-content/10'}`}
> >
{status} {status}
</span> </span>
@@ -25,7 +258,7 @@ function StatusBadge({ status }: { status: string }) {
function MapBadge({ map }: { map: string }) { function MapBadge({ map }: { map: string }) {
return ( return (
<span className="inline-flex items-center text-[11px] px-1.5 py-0.5 border border-base-content/10 text-base-content/50"> <span className="inline-flex items-center whitespace-nowrap text-xs px-1.5 py-0.5 border border-base-content/10 text-base-content/50">
{map} {map}
</span> </span>
); );
@@ -46,13 +279,110 @@ function getStatusLabel(status: string) {
} }
} }
function formatCompactDateTime(dateLike: string) {
const date = new Date(dateLike);
if (Number.isNaN(date.getTime())) return '';
const weekday = new Intl.DateTimeFormat('ko-KR', {
weekday: 'short',
}).format(date);
const hours = String(date.getHours()).padStart(2, '0');
const minutes = String(date.getMinutes()).padStart(2, '0');
return `${date.getMonth() + 1}/${date.getDate()} (${weekday}) ${hours}:${minutes}`;
}
function HistoryMetaText({
map,
participants,
result,
}: {
map: string;
participants: number;
result?: string;
}) {
return (
<div className="flex flex-wrap items-center gap-x-1.5 gap-y-1 text-xs text-base-content/45">
<span>{map}</span>
<span className="text-base-content/20">·</span>
<span>{participants}명</span>
{result && (
<>
<span className="text-base-content/20">·</span>
<span>{result}</span>
</>
)}
</div>
);
}
interface HistoryPaginationProps {
page: number;
pageCount: number;
total: number;
isFetching: boolean;
onPrevious: () => void;
onNext: () => void;
}
function HistoryPagination({
page,
pageCount,
total,
isFetching,
onPrevious,
onNext,
}: HistoryPaginationProps) {
const hasPrevious = page > 1;
const hasNext = page < pageCount;
return (
<div className="flex flex-wrap items-center gap-2 text-xs text-base-content/40">
<span className="font-medium whitespace-nowrap">
총 {total}개 · {page}/{pageCount}페이지
</span>
<div className="flex items-center gap-1">
<button
type="button"
className="btn btn-ghost btn-xs px-2"
disabled={!hasPrevious || isFetching}
onClick={onPrevious}
>
<ChevronLeft className="h-3.5 w-3.5" aria-hidden="true" />
이전
</button>
<button
type="button"
className="btn btn-ghost btn-xs px-2"
disabled={!hasNext || isFetching}
onClick={onNext}
>
다음
<ChevronRight className="h-3.5 w-3.5" aria-hidden="true" />
</button>
</div>
</div>
);
}
export default function HomePage() { export default function HomePage() {
const [timelineNow] = useState(() => new Date().toISOString());
const [historyPage, setHistoryPage] = useState(1);
const upcomingMatchesQuery = useMatches( const upcomingMatchesQuery = useMatches(
{ limit: UPCOMING_MATCH_LIST_LIMIT }, {
limit: UPCOMING_MATCH_LIST_LIMIT,
scheduledFrom: timelineNow,
sort: 'asc',
},
DEFAULT_COMMUNITY_ID, DEFAULT_COMMUNITY_ID,
); );
const finishedMatchesQuery = useMatches( const historyMatchesQuery = useMatchesPage(
{ status: 'finished', limit: 10 }, {
limit: HISTORY_MATCH_PAGE_SIZE,
page: historyPage,
scheduledTo: timelineNow,
sort: 'desc',
},
DEFAULT_COMMUNITY_ID, DEFAULT_COMMUNITY_ID,
); );
const meQuery = useMe(); const meQuery = useMe();
@@ -67,15 +397,11 @@ export default function HomePage() {
); );
} }
if (upcomingMatchesQuery.isLoading || finishedMatchesQuery.isLoading) { if (upcomingMatchesQuery.isLoading) {
return ( return <HomePageSkeleton />;
<main className="max-w-5xl mx-auto px-4 sm:px-6 py-20 text-center">
<span className="text-sm text-base-content/40">매치 목록을 불러오는 중...</span>
</main>
);
} }
if (upcomingMatchesQuery.error || finishedMatchesQuery.error) { if (upcomingMatchesQuery.error) {
return ( return (
<main className="max-w-5xl mx-auto px-4 sm:px-6 py-20 text-center"> <main className="max-w-5xl mx-auto px-4 sm:px-6 py-20 text-center">
<span className="text-sm text-red-500"> <span className="text-sm text-red-500">
@@ -87,8 +413,26 @@ export default function HomePage() {
const upcomingMatches = const upcomingMatches =
upcomingMatchesQuery.data?.map(mapApiMatchToMatchDetail) ?? []; upcomingMatchesQuery.data?.map(mapApiMatchToMatchDetail) ?? [];
const finishedMatches = const historyMatches =
finishedMatchesQuery.data?.map(mapApiMatchToMatchDetail) ?? []; historyMatchesQuery.data?.matches.map((match) => ({
...mapApiMatchToMatchDetail(match),
compactDateTime: formatCompactDateTime(match.scheduledAt),
})) ?? [];
const historyTotal = historyMatchesQuery.data?.total ?? 0;
const historyLimit =
historyMatchesQuery.data?.limit ?? HISTORY_MATCH_PAGE_SIZE;
const historyPageCount = Math.max(
1,
Math.ceil(historyTotal / historyLimit),
);
const isHistoryPageLoading =
historyMatchesQuery.isLoading ||
(historyMatchesQuery.isFetching && historyMatchesQuery.isPlaceholderData);
const hasHistoryError =
Boolean(historyMatchesQuery.error) && !historyMatchesQuery.data;
const goToPreviousHistoryPage = () =>
setHistoryPage((page) => Math.max(1, page - 1));
const goToNextHistoryPage = () => setHistoryPage((page) => page + 1);
const nextMatch = upcomingMatches[0]; const nextMatch = upcomingMatches[0];
const upcomingCards = (nextMatch const upcomingCards = (nextMatch
? upcomingMatches.slice(1) ? upcomingMatches.slice(1)
@@ -128,7 +472,7 @@ export default function HomePage() {
{nextMatch ? ( {nextMatch ? (
<Link to={`/match/${nextMatch.id}`} className="block group"> <Link to={`/match/${nextMatch.id}`} className="block group">
<div className="border border-base-content/10 bg-base-200/50 hover:bg-base-200 transition-colors"> <div className="border border-base-content/10 bg-base-200/50 hover:bg-base-200 transition-colors">
<div className="p-5 sm:p-6"> <div className="p-5 sm:p-6 min-h-[150px]">
<div className="flex flex-col sm:flex-row sm:items-start sm:justify-between gap-4"> <div className="flex flex-col sm:flex-row sm:items-start sm:justify-between gap-4">
<div className="space-y-2.5"> <div className="space-y-2.5">
<div className="flex items-center gap-2.5 flex-wrap"> <div className="flex items-center gap-2.5 flex-wrap">
@@ -143,7 +487,7 @@ export default function HomePage() {
<div className="flex items-center gap-3 text-xs text-base-content/40 flex-wrap"> <div className="flex items-center gap-3 text-xs text-base-content/40 flex-wrap">
<span>{nextMatch.date} {nextMatch.time}</span> <span>{nextMatch.date} {nextMatch.time}</span>
<span className="text-base-content/15">|</span> <span className="text-base-content/15">|</span>
<span> <span className="bg-accent text-accent-content px-1.5 py-0.5 font-semibold">
{nextMatch.participants.length}/{nextMatch.maxParticipants}명 {nextMatch.participants.length}/{nextMatch.maxParticipants}명
</span> </span>
<span className="text-base-content/15">|</span> <span className="text-base-content/15">|</span>
@@ -151,7 +495,7 @@ export default function HomePage() {
</div> </div>
</div> </div>
<div className="sm:shrink-0"> <div className="sm:shrink-0">
<span className="btn btn-primary btn-sm px-6 text-xs font-semibold"> <span className="btn btn-secondary btn-sm px-6 text-xs font-semibold">
상세 보기 상세 보기
</span> </span>
</div> </div>
@@ -160,8 +504,10 @@ export default function HomePage() {
</div> </div>
</Link> </Link>
) : ( ) : (
<div className="border border-base-content/10 bg-base-100 px-5 py-10 text-center text-sm text-base-content/40"> <div className="border border-base-content/10 bg-base-200/50">
아직 등록된 내전이 없습니다. <div className="p-5 sm:p-6 min-h-[150px] flex items-center justify-center text-center text-sm text-base-content/40">
{EMPTY_SCHEDULE_TEXT}
</div>
</div> </div>
)} )}
</section> </section>
@@ -174,7 +520,7 @@ export default function HomePage() {
{upcomingCards.length > 0 ? ( {upcomingCards.length > 0 ? (
upcomingCards.map((match) => ( upcomingCards.map((match) => (
<Link key={match.id} to={`/match/${match.id}`}> <Link key={match.id} to={`/match/${match.id}`}>
<div className="bg-base-100 hover:bg-base-200/50 transition-colors cursor-pointer h-full p-4"> <div className="bg-base-100 hover:bg-base-200/50 transition-colors cursor-pointer h-full p-4 min-h-[122px]">
<div className="flex items-center justify-between mb-2.5"> <div className="flex items-center justify-between mb-2.5">
<h3 className="text-sm font-bold text-base-content truncate mr-2"> <h3 className="text-sm font-bold text-base-content truncate mr-2">
{match.title} {match.title}
@@ -194,70 +540,144 @@ export default function HomePage() {
</Link> </Link>
)) ))
) : ( ) : (
<div className="bg-base-100 px-4 py-6 text-sm text-base-content/35 col-span-full"> <div className="bg-base-100 h-full p-4 min-h-[122px] flex items-center justify-center text-center text-sm text-base-content/35">
예정된 추가 매치가 없습니다. {EMPTY_SCHEDULE_TEXT}
</div> </div>
)} )}
</div> </div>
</section> </section>
<section className="pb-12"> <section
className="pb-12"
aria-busy={isHistoryPageLoading}
aria-live="polite"
>
<h2 className="text-xs font-bold text-base-content/40 uppercase tracking-widest mb-3"> <h2 className="text-xs font-bold text-base-content/40 uppercase tracking-widest mb-3">
지난 내전 기록 지난 내전 기록
</h2> </h2>
<div className="border border-base-content/10 overflow-x-auto"> {isHistoryPageLoading ? (
<table className="w-full text-left"> <HistoryRecordsSkeleton rows={HISTORY_MATCH_PAGE_SIZE} />
<thead> ) : hasHistoryError ? (
<tr className="bg-base-200/60 border-b border-base-content/10 text-[11px] uppercase tracking-wider text-base-content/40"> <div className="border border-base-content/10 px-4 py-8 text-center text-sm text-red-500">
<th className="py-2.5 px-4 font-semibold">날짜</th> 지난 내전 기록을 불러오지 못했습니다.
<th className="py-2.5 px-4 font-semibold">내전</th> </div>
<th className="py-2.5 px-4 font-semibold">맵</th> ) : (
<th className="py-2.5 px-4 font-semibold">참가</th> <>
<th className="py-2.5 px-4 font-semibold">결과</th> {/* 데스크톱: 테이블 */}
</tr> <div className="hidden md:block border border-base-content/10 overflow-x-auto">
</thead> <table className="w-full table-fixed text-left">
<tbody> <HistoryTableColGroup />
{finishedMatches.length > 0 ? ( <HistoryTableHeader />
finishedMatches.map((match) => ( <tbody>
<tr {historyMatches.length > 0 ? (
key={match.id} historyMatches.map((match) => (
className="border-b border-base-content/5 last:border-b-0 hover:bg-base-content/[0.02] transition-colors" <tr
> key={match.id}
<td className="py-2.5 px-4 text-xs text-base-content/40 whitespace-nowrap"> className={`${HISTORY_TABLE_ROW_CLASS} hover:bg-base-content/[0.02] transition-colors`}
{match.date}
</td>
<td className="py-2.5 px-4">
<Link
to={`/match/${match.id}`}
className="text-sm font-medium text-base-content hover:text-primary transition-colors"
> >
{match.title} <td className="py-2.5 px-4 text-xs text-base-content/40 whitespace-nowrap">
</Link> {match.date}
</td> </td>
<td className="py-2.5 px-4"> <td className="py-2.5 px-4">
<MapBadge map={match.map} /> <Link
</td> to={`/match/${match.id}`}
<td className="py-2.5 px-4 text-xs text-base-content/50"> className="block truncate text-sm font-medium text-base-content hover:text-primary transition-colors"
{match.participants.length}명 >
</td> {match.title}
<td className="py-2.5 px-4 text-xs text-base-content/50"> </Link>
{match.result?.winner ? `${match.result.winner} 승리` : '-'} </td>
</td> <td className="py-2.5 px-4">
</tr> <StatusBadge status={getStatusLabel(match.status)} />
)) </td>
<td className="py-2.5 px-4">
<MapBadge map={match.map} />
</td>
<td className="py-2.5 px-4 text-xs text-base-content/50 whitespace-nowrap">
{match.participants.length}명
</td>
<td className="py-2.5 px-4 text-xs text-base-content/50 whitespace-nowrap">
<span className="block truncate">
{match.result?.winner
? `${match.result.winner} 승리`
: '-'}
</span>
</td>
</tr>
))
) : (
<tr>
<td
colSpan={6}
className="py-6 px-4 text-sm text-base-content/35 text-center"
>
아직 내전 기록이 없습니다.
</td>
</tr>
)}
</tbody>
</table>
</div>
{/* 모바일: 카드 리스트 */}
<div className="md:hidden border border-base-content/10">
{historyMatches.length > 0 ? (
historyMatches.map((match) => {
const resultLabel = match.result?.winner
? `${match.result.winner} 승리`
: undefined;
return (
<Link
key={match.id}
to={`/match/${match.id}`}
className="block border-b border-base-content/5 last:border-b-0 p-3 hover:bg-base-content/[0.02] transition-colors"
>
<div className="flex items-start justify-between gap-3">
<div className="min-w-0 flex-1">
<div className="text-xs font-medium text-base-content/40">
{match.compactDateTime ||
`${match.date} ${match.time}`}
</div>
<div className="mt-1 text-sm font-semibold leading-snug text-base-content break-words">
{match.title}
</div>
</div>
<div className="shrink-0">
<StatusBadge
status={getStatusLabel(match.status)}
/>
</div>
</div>
<div className="mt-2">
<HistoryMetaText
map={match.map}
participants={match.participants.length}
result={resultLabel}
/>
</div>
</Link>
);
})
) : ( ) : (
<tr> <div className="py-6 px-4 text-sm text-base-content/35 text-center">
<td 아직 내전 기록이 없습니다.
colSpan={5} </div>
className="py-6 px-4 text-sm text-base-content/35 text-center"
>
아직 종료된 내전 기록이 없습니다.
</td>
</tr>
)} )}
</tbody> </div>
</table> </>
</div> )}
{!hasHistoryError && historyTotal > 0 && (
<div className="mt-3 flex justify-end">
<HistoryPagination
page={historyPage}
pageCount={historyPageCount}
total={historyTotal}
isFetching={historyMatchesQuery.isFetching}
onPrevious={goToPreviousHistoryPage}
onNext={goToNextHistoryPage}
/>
</div>
)}
</section> </section>
</main> </main>
); );
+92 -49
View File
@@ -1,24 +1,32 @@
import { Link, useLocation, useParams } from 'react-router'; import { Link, useLocation, useParams } from "react-router";
import { useDdragonManifest, useInternalMatchDetail } from '../api/hooks'; import { useDdragonManifest, useInternalMatchDetail } from "../api/hooks";
import type { ApiInternalMatchDetailResponse, TeamSide } from '../api/types'; import type { ApiInternalMatchDetailResponse, TeamSide } from "../api/types";
import { DEFAULT_COMMUNITY_ID } from '../config'; import { DEFAULT_COMMUNITY_ID } from "../config";
import { championDisplayName, championIconUrl, itemIconUrl } from '../lib/ddragon'; import {
import { sideShortLabel, teamIndexColorClasses, teamIndexLabel } from '../lib/league'; championDisplayName,
import { LANE_LABELS } from '../lib/riot-history'; championIconUrl,
itemIconUrl,
} from "../lib/ddragon";
import {
sideShortLabel,
teamIndexColorClasses,
teamIndexLabel,
} from "../lib/league";
import { LANE_LABELS } from "../lib/riot-history";
function formatDateTime(value: string | number) { function formatDateTime(value: string | number) {
return new Intl.DateTimeFormat('ko-KR', { return new Intl.DateTimeFormat("ko-KR", {
month: 'long', month: "long",
day: 'numeric', day: "numeric",
hour: '2-digit', hour: "2-digit",
minute: '2-digit', minute: "2-digit",
}).format(new Date(value)); }).format(new Date(value));
} }
function formatDuration(seconds: number) { function formatDuration(seconds: number) {
const minutes = Math.floor(seconds / 60); const minutes = Math.floor(seconds / 60);
const rest = seconds % 60; const rest = seconds % 60;
return `${minutes}:${String(rest).padStart(2, '0')}`; return `${minutes}:${String(rest).padStart(2, "0")}`;
} }
function sideLabel(side: TeamSide) { function sideLabel(side: TeamSide) {
@@ -26,7 +34,9 @@ function sideLabel(side: TeamSide) {
} }
function sideClass(side: TeamSide) { function sideClass(side: TeamSide) {
return side === 'blue' ? 'text-blue-400 border-blue-500/20' : 'text-red-400 border-red-500/20'; return side === "blue"
? "text-blue-400 border-blue-500/20"
: "text-red-400 border-red-500/20";
} }
function ChampionCell({ function ChampionCell({
@@ -34,16 +44,18 @@ function ChampionCell({
manifest, manifest,
}: { }: {
championId: number; championId: number;
manifest: ReturnType<typeof useDdragonManifest>['data']; manifest: ReturnType<typeof useDdragonManifest>["data"];
}) { }) {
const icon = championIconUrl(manifest, championId); const icon = championIconUrl(manifest, championId);
const name = championDisplayName(manifest, championId) ?? String(championId); const name = championDisplayName(manifest, championId) ?? String(championId);
return ( return (
<div className="flex items-center gap-2 min-w-0"> <div className="flex items-center gap-2 min-w-0">
<span className="w-8 h-8 bg-base-content/10 overflow-hidden shrink-0"> <span className="w-8 h-8 bg-base-content/10 overflow-hidden shrink-0">
{icon ? <img src={icon} alt="" className="w-full h-full object-cover" /> : null} {icon ? (
<img src={icon} alt="" className="w-full h-full object-cover" />
) : null}
</span> </span>
<span className="font-bold text-[13px] truncate">{name}</span> <span className="font-bold text-sm truncate">{name}</span>
</div> </div>
); );
} }
@@ -55,7 +67,7 @@ function ItemStrip({
}: { }: {
items: number[]; items: number[];
trinket: number; trinket: number;
manifest: ReturnType<typeof useDdragonManifest>['data']; manifest: ReturnType<typeof useDdragonManifest>["data"];
}) { }) {
return ( return (
<div className="flex flex-wrap gap-1"> <div className="flex flex-wrap gap-1">
@@ -66,7 +78,9 @@ function ItemStrip({
key={`${itemId}-${index}`} key={`${itemId}-${index}`}
className="w-5 h-5 bg-base-content/10 border border-base-content/5 overflow-hidden" className="w-5 h-5 bg-base-content/10 border border-base-content/5 overflow-hidden"
> >
{icon ? <img src={icon} alt="" className="w-full h-full object-cover" /> : null} {icon ? (
<img src={icon} alt="" className="w-full h-full object-cover" />
) : null}
</span> </span>
); );
})} })}
@@ -78,8 +92,8 @@ function GamePanel({
game, game,
manifest, manifest,
}: { }: {
game: ApiInternalMatchDetailResponse['games'][number]; game: ApiInternalMatchDetailResponse["games"][number];
manifest: ReturnType<typeof useDdragonManifest>['data']; manifest: ReturnType<typeof useDdragonManifest>["data"];
}) { }) {
const location = useLocation(); const location = useLocation();
const historyBackTo = `${location.pathname}${location.search}${location.hash}`; const historyBackTo = `${location.pathname}${location.search}${location.hash}`;
@@ -91,8 +105,9 @@ function GamePanel({
<h2 className="text-sm font-black text-base-content"> <h2 className="text-sm font-black text-base-content">
{game.gameNumber}경기 {game.gameNumber}경기
</h2> </h2>
<p className="mt-1 text-[11px] text-base-content/35"> <p className="mt-1 text-xs text-base-content/35">
{formatDateTime(game.gameCreation)} · {formatDuration(game.gameDuration)} ·{' '} {formatDateTime(game.gameCreation)} ·{" "}
{formatDuration(game.gameDuration)} ·{" "}
<span className="font-mono">{game.riotMatchId}</span> <span className="font-mono">{game.riotMatchId}</span>
</p> </p>
</div> </div>
@@ -100,27 +115,33 @@ function GamePanel({
{game.teams.map((team) => ( {game.teams.map((team) => (
<span <span
key={team.side} key={team.side}
className={`border px-2 py-1 text-[11px] font-black ${sideClass(team.side)} ${ className={`border px-2 py-1 text-xs font-black ${sideClass(team.side)} ${
team.win ? 'bg-base-content/5' : 'opacity-40' team.win ? "bg-base-content/5" : "opacity-40"
}`} }`}
> >
{teamIndexLabel(team.teamIndex)} ({sideLabel(team.side)}){' '} {teamIndexLabel(team.teamIndex)} ({sideLabel(team.side)}){" "}
{team.win ? '승' : '패'} {team.win ? "승" : "패"}
</span> </span>
))} ))}
</div> </div>
</div> </div>
{game.teams.map((team) => ( {game.teams.map((team) => (
<div key={team.side} className="border-b border-base-content/8 last:border-b-0"> <div
<div className={`px-4 py-2 text-[11px] font-black uppercase tracking-wider ${sideClass(team.side)}`}> key={team.side}
{teamIndexLabel(team.teamIndex)} ({sideLabel(team.side)}) · 바론 {team.objectives.baron} · 드래곤{' '} className="border-b border-base-content/8 last:border-b-0"
{team.objectives.dragon} · 타워 {team.objectives.tower} >
<div
className={`px-4 py-2 text-xs font-black uppercase tracking-wider ${sideClass(team.side)}`}
>
{teamIndexLabel(team.teamIndex)} ({sideLabel(team.side)}) · 바론{" "}
{team.objectives.baron} · 드래곤 {team.objectives.dragon} · 타워{" "}
{team.objectives.tower}
</div> </div>
<div className="overflow-x-auto"> <div className="overflow-x-auto">
<table className="w-full text-left min-w-[980px]"> <table className="w-full text-left min-w-[980px]">
<thead> <thead>
<tr className="bg-base-content/[0.02] text-[11px] text-base-content/35 uppercase tracking-wider"> <tr className="bg-base-content/[0.02] text-xs text-base-content/35 uppercase tracking-wider">
<th className="px-3 py-2">소환사</th> <th className="px-3 py-2">소환사</th>
<th className="px-3 py-2">챔피언</th> <th className="px-3 py-2">챔피언</th>
<th className="px-3 py-2 text-center">포지션</th> <th className="px-3 py-2 text-center">포지션</th>
@@ -143,39 +164,44 @@ function GamePanel({
<Link <Link
to={`/users/${participant.userId}/history?queueGroup=internal`} to={`/users/${participant.userId}/history?queueGroup=internal`}
state={{ backTo: historyBackTo }} state={{ backTo: historyBackTo }}
className="font-bold text-[13px] hover:text-primary" className="font-bold text-sm hover:text-primary"
> >
{participant.summonerName} {participant.summonerName}
</Link> </Link>
) : ( ) : (
<span className="font-bold text-[13px]"> <span className="font-bold text-sm">
{participant.summonerName} {participant.summonerName}
</span> </span>
)} )}
</td> </td>
<td className="px-3 py-2"> <td className="px-3 py-2">
<ChampionCell championId={participant.championId} manifest={manifest} /> <ChampionCell
championId={participant.championId}
manifest={manifest}
/>
</td> </td>
<td className="px-3 py-2 text-center text-[12px]"> <td className="px-3 py-2 text-center text-xs">
{LANE_LABELS[participant.teamPosition] ?? participant.teamPosition ?? '-'} {LANE_LABELS[participant.teamPosition] ??
participant.teamPosition ??
"-"}
</td> </td>
<td className="px-3 py-2 text-center text-[13px] font-black tabular-nums"> <td className="px-3 py-2 text-center text-sm font-black tabular-nums">
{participant.kills} {participant.kills}
<span className="text-base-content/25"> / </span> <span className="text-base-content/25"> / </span>
<span className="text-red-400">{participant.deaths}</span> <span className="text-red-400">{participant.deaths}</span>
<span className="text-base-content/25"> / </span> <span className="text-base-content/25"> / </span>
{participant.assists} {participant.assists}
</td> </td>
<td className="px-3 py-2 text-center text-[12px] tabular-nums"> <td className="px-3 py-2 text-center text-xs tabular-nums">
{participant.cs} ({participant.csPerMin}/m) {participant.cs} ({participant.csPerMin}/m)
</td> </td>
<td className="px-3 py-2 text-center text-[12px] tabular-nums"> <td className="px-3 py-2 text-center text-xs tabular-nums">
{participant.gpm} {participant.gpm}
</td> </td>
<td className="px-3 py-2 text-center text-[12px] tabular-nums"> <td className="px-3 py-2 text-center text-xs tabular-nums">
{participant.killParticipation}% {participant.killParticipation}%
</td> </td>
<td className="px-3 py-2 text-center text-[12px] tabular-nums"> <td className="px-3 py-2 text-center text-xs tabular-nums">
{participant.damageShare}% {participant.damageShare}%
</td> </td>
<td className="px-3 py-2"> <td className="px-3 py-2">
@@ -248,21 +274,38 @@ export default function InternalMatchDetailPage() {
{detail.match.title} {detail.match.title}
</h1> </h1>
<p className="mt-2 text-sm text-base-content/45"> <p className="mt-2 text-sm text-base-content/45">
{formatDateTime(detail.match.scheduledAt)} · {detail.match.gameCount}전제 {formatDateTime(detail.match.scheduledAt)} ·{" "}
{detail.match.gameCount}전제
</p> </p>
</div> </div>
{primarySeries && ( {primarySeries && (
<div className="flex items-center gap-6"> <div className="flex items-center gap-6">
<div className={primarySeries.winnerTeamIndex === primarySeries.teamAIndex ? teamIndexColorClasses(primarySeries.teamAIndex).text : 'text-base-content/30'}> <div
<div className="text-4xl font-black tabular-nums">{primarySeries.teamAWins}</div> className={
<div className="text-[10px] font-bold uppercase tracking-wider"> primarySeries.winnerTeamIndex === primarySeries.teamAIndex
? teamIndexColorClasses(primarySeries.teamAIndex).text
: "text-base-content/30"
}
>
<div className="text-4xl font-black tabular-nums">
{primarySeries.teamAWins}
</div>
<div className="text-xs font-bold uppercase tracking-wider">
{teamName(primarySeries.teamAIndex)} {teamName(primarySeries.teamAIndex)}
</div> </div>
</div> </div>
<div className="text-base-content/15 text-xs font-black">VS</div> <div className="text-base-content/15 text-xs font-black">VS</div>
<div className={primarySeries.winnerTeamIndex === primarySeries.teamBIndex ? teamIndexColorClasses(primarySeries.teamBIndex).text : 'text-base-content/30'}> <div
<div className="text-4xl font-black tabular-nums">{primarySeries.teamBWins}</div> className={
<div className="text-[10px] font-bold uppercase tracking-wider"> primarySeries.winnerTeamIndex === primarySeries.teamBIndex
? teamIndexColorClasses(primarySeries.teamBIndex).text
: "text-base-content/30"
}
>
<div className="text-4xl font-black tabular-nums">
{primarySeries.teamBWins}
</div>
<div className="text-xs font-bold uppercase tracking-wider">
{teamName(primarySeries.teamBIndex)} {teamName(primarySeries.teamBIndex)}
</div> </div>
</div> </div>
+361 -136
View File
@@ -25,7 +25,6 @@ import { apiFetch, ApiError } from "../lib/api";
import { profileIconUrl } from "../lib/ddragon"; import { profileIconUrl } from "../lib/ddragon";
import { import {
POSITION_ORDER, POSITION_ORDER,
positionIcon,
positionLabel, positionLabel,
sideShortLabel, sideShortLabel,
teamIndexColorClasses, teamIndexColorClasses,
@@ -88,6 +87,9 @@ const PARTICIPANT_TIER_LABELS: Record<string, string> = {
UNRANKED: "언랭크", UNRANKED: "언랭크",
}; };
const PARTICIPANT_TABLE_ROW_CLASS =
"h-12 border-b border-base-content/5 last:border-b-0";
function captainSlotKey(slot: CaptainSelectionSlot) { function captainSlotKey(slot: CaptainSelectionSlot) {
return String(slot.teamIndex); return String(slot.teamIndex);
} }
@@ -153,25 +155,6 @@ function buildCaptainSlots(
})); }));
} }
function PosBadge({ pos, sub }: { pos: Position; sub?: boolean }) {
return (
<span
className={`inline-flex items-center gap-1.5 text-[11px] font-medium px-1.5 py-0.5 border ${
sub
? "border-base-content/8 text-base-content/35 bg-transparent"
: "border-primary/20 text-primary bg-primary/5"
}`}
>
<img
src={positionIcon[pos]}
alt=""
className="w-3.5 h-3.5 object-contain mr-4px"
/>
<span>{positionLabel[pos]}</span>
</span>
);
}
function tierByQueue(tiers: ApiTierInfo[], queueType: string) { function tierByQueue(tiers: ApiTierInfo[], queueType: string) {
return tiers.find((tier) => tier.queueType === queueType); return tiers.find((tier) => tier.queueType === queueType);
} }
@@ -184,16 +167,34 @@ function QueueRankCell({
tier?: ApiTierInfo; tier?: ApiTierInfo;
}) { }) {
return ( return (
<span className="inline-flex w-[54px] items-center gap-1"> <span className="grid grid-cols-[27px_auto] items-center gap-1.5">
<span>{label}</span> <span className="text-xs font-medium text-base-content/50">
{label}
</span>
<RankBadge tier={tier} size="sm" tooltipPlacement="left" /> <RankBadge tier={tier} size="sm" tooltipPlacement="left" />
</span> </span>
); );
} }
function PreferredPositionText({
mainPosition,
subPosition,
}: {
mainPosition: Position;
subPosition: Position;
}) {
return (
<span className="inline-flex flex-col gap-0.5 text-xs font-medium leading-tight text-base-content/55 whitespace-nowrap sm:flex-row sm:items-center sm:gap-1 sm:text-sm sm:leading-normal">
<span>{positionLabel[mainPosition]}</span>
<span className="hidden sm:inline">/</span>
<span>{positionLabel[subPosition]}</span>
</span>
);
}
function SoloRankPrefix({ tier }: { tier?: ApiTierInfo }) { function SoloRankPrefix({ tier }: { tier?: ApiTierInfo }) {
return ( return (
<span className="inline-flex shrink-0 items-center gap-1 text-[10px] font-black text-base-content/35"> <span className="inline-flex shrink-0 items-center gap-1 text-xs font-black text-base-content/35">
{/* <span>SOLO</span> */} {/* <span>SOLO</span> */}
<RankBadge tier={tier} size="sm" tooltipPlacement="left" /> <RankBadge tier={tier} size="sm" tooltipPlacement="left" />
</span> </span>
@@ -214,7 +215,7 @@ function TierCell({ participant }: { participant: ParticipantView }) {
const flexTier = tierByQueue(tiers, "RANKED_FLEX_SR"); const flexTier = tierByQueue(tiers, "RANKED_FLEX_SR");
return ( return (
<div className="flex items-center gap-2 text-[10px] font-black text-base-content/35 whitespace-nowrap"> <div className="grid grid-cols-1 items-center gap-1 text-xs font-black text-base-content/35 whitespace-nowrap sm:grid-cols-[4.25rem_4.25rem] sm:gap-2">
<QueueRankCell label="SOLO" tier={soloTier} /> <QueueRankCell label="SOLO" tier={soloTier} />
<QueueRankCell label="FLEX" tier={flexTier} /> <QueueRankCell label="FLEX" tier={flexTier} />
</div> </div>
@@ -286,7 +287,7 @@ function PositionSelect({
value={value} value={value}
disabled={disabled} disabled={disabled}
onChange={(event) => onChange(event.target.value as Position)} onChange={(event) => onChange(event.target.value as Position)}
className={`h-7 border bg-base-100 pl-1.5 pr-1 text-[11px] font-medium focus:border-primary/30 focus:outline-none disabled:opacity-50 ${ className={`h-7 w-16 border bg-base-100 pl-1.5 pr-1 text-xs font-medium focus:border-primary/30 focus:outline-none disabled:opacity-50 ${
sub sub
? "border-base-content/10 text-base-content/45" ? "border-base-content/10 text-base-content/45"
: "border-primary/20 text-primary" : "border-primary/20 text-primary"
@@ -334,19 +335,20 @@ function ParticipantRow({
: participant.mainPosition; : participant.mainPosition;
admin.onChangePositions(participant.userId, main, next); admin.onChangePositions(participant.userId, main, next);
}; };
return ( return (
<tr className="border-b border-base-content/5 last:border-b-0 hover:bg-base-content/[0.02] transition-colors"> <tr
<td className="py-2 px-3 text-center text-[11px] text-base-content/30 w-8"> className={`${PARTICIPANT_TABLE_ROW_CLASS} hover:bg-base-content/[0.02] transition-colors`}
>
<td className="hidden py-2 px-3 text-center text-xs text-base-content/30 w-8 sm:table-cell">
{index + 1} {index + 1}
</td> </td>
<td className="py-2 px-3"> <td className="py-2 px-3">
<Link <Link
to={`/users/${participant.userId}/history`} to={`/users/${participant.userId}/history`}
state={{ backTo: historyBackTo }} state={{ backTo: historyBackTo }}
className="flex items-center gap-2 group" className="flex min-w-0 items-center gap-2 group"
> >
<div className="w-7 h-7 bg-base-content/10 overflow-hidden shrink-0"> <div className="h-8 w-8 bg-base-content/10 overflow-hidden shrink-0">
<img <img
src={profileIconUrl(ddragon, participant.profileIconId)} src={profileIconUrl(ddragon, participant.profileIconId)}
alt="" alt=""
@@ -355,13 +357,13 @@ function ParticipantRow({
/> />
</div> </div>
<div className="min-w-0"> <div className="min-w-0">
<span className="font-medium text-[13px] text-base-content truncate block leading-tight group-hover:text-primary transition-colors"> <span className="font-medium text-sm text-base-content block leading-tight break-words group-hover:text-primary transition-colors sm:truncate">
{participant.summonerName} {participant.summonerName}
</span> </span>
<span className="inline-flex items-center gap-1 text-[10px] text-base-content/25 leading-tight"> <span className="inline-flex items-center gap-1 text-xs text-base-content/25 leading-tight">
#{participant.tag} #{participant.tag}
{participant.excluded && ( {participant.excluded && (
<span className="border border-amber-500/20 bg-amber-500/10 px-1 text-[9px] font-bold text-amber-500"> <span className="border border-amber-500/20 bg-amber-500/10 px-1 text-xs font-bold text-amber-500">
제외 제외
</span> </span>
)} )}
@@ -374,24 +376,28 @@ function ParticipantRow({
</td> </td>
{assignedPos ? ( {assignedPos ? (
<td className="py-2 px-3"> <td className="py-2 px-3">
<PosBadge pos={assignedPos} /> <PreferredPositionText
mainPosition={participant.mainPosition}
subPosition={participant.subPosition}
/>
</td> </td>
) : admin ? ( ) : admin ? (
<> <>
<td className="py-2 px-3"> <td className="py-2 px-3">
<PositionSelect <span className="inline-flex items-center gap-1 whitespace-nowrap">
value={participant.mainPosition} <PositionSelect
disabled={admin.isUpdating} value={participant.mainPosition}
onChange={handleMainChange} disabled={admin.isUpdating}
/> onChange={handleMainChange}
</td> />
<td className="py-2 px-3"> <span className="text-xs text-base-content/35">/</span>
<PositionSelect <PositionSelect
value={participant.subPosition} value={participant.subPosition}
sub sub
disabled={admin.isUpdating} disabled={admin.isUpdating}
onChange={handleSubChange} onChange={handleSubChange}
/> />
</span>
</td> </td>
<td className="py-2 px-3 w-20 min-w-[5rem] whitespace-nowrap text-right"> <td className="py-2 px-3 w-20 min-w-[5rem] whitespace-nowrap text-right">
{confirmingRemove ? ( {confirmingRemove ? (
@@ -400,14 +406,14 @@ function ParticipantRow({
type="button" type="button"
disabled={admin.isRemoving} disabled={admin.isRemoving}
onClick={() => admin.onRemove(participant.userId)} onClick={() => admin.onRemove(participant.userId)}
className="text-[10px] font-bold text-red-400 hover:text-red-300 disabled:opacity-50" className="text-xs font-bold text-red-400 hover:text-red-300 disabled:opacity-50"
> >
{admin.isRemoving ? "제외 중..." : "확인"} {admin.isRemoving ? "제외 중..." : "확인"}
</button> </button>
<button <button
type="button" type="button"
onClick={() => setConfirmingRemove(false)} onClick={() => setConfirmingRemove(false)}
className="text-[10px] text-base-content/35 hover:text-base-content/60" className="text-xs text-base-content/35 hover:text-base-content/60"
> >
취소 취소
</button> </button>
@@ -439,19 +445,178 @@ function ParticipantRow({
</td> </td>
</> </>
) : ( ) : (
<> <td className="py-2 px-3">
<td className="py-2 px-3"> <PreferredPositionText
<PosBadge pos={participant.mainPosition} /> mainPosition={participant.mainPosition}
</td> subPosition={participant.subPosition}
<td className="py-2 px-3"> />
<PosBadge pos={participant.subPosition} sub /> </td>
</td>
</>
)} )}
</tr> </tr>
); );
} }
function TeamParticipantMobileRow({
participant,
}: {
participant: ParticipantView;
}) {
const { data: ddragon } = useDdragonManifest();
const location = useLocation();
const historyBackTo = `${location.pathname}${location.search}${location.hash}`;
return (
<div className="grid grid-cols-[minmax(0,1fr)_64px_58px] items-center gap-x-2 border-b border-base-content/5 px-3 py-2 last:border-b-0">
<Link
to={`/users/${participant.userId}/history`}
state={{ backTo: historyBackTo }}
className="flex min-w-0 items-center gap-2 group"
>
<div className="h-8 w-8 shrink-0 overflow-hidden bg-base-content/10">
<img
src={profileIconUrl(ddragon, participant.profileIconId)}
alt=""
className="h-full w-full object-cover"
loading="lazy"
/>
</div>
<div className="min-w-0">
<span className="block break-words text-sm font-medium leading-tight text-base-content transition-colors group-hover:text-primary">
{participant.summonerName}
</span>
<span className="inline-flex items-center gap-1 text-xs leading-tight text-base-content/25">
#{participant.tag}
{participant.excluded && (
<span className="border border-amber-500/20 bg-amber-500/10 px-1 text-xs font-bold text-amber-500">
제외
</span>
)}
</span>
</div>
</Link>
<TierCell participant={participant} />
<PreferredPositionText
mainPosition={participant.mainPosition}
subPosition={participant.subPosition}
/>
</div>
);
}
function ParticipantMobileRow({
participant,
admin,
}: {
participant: ParticipantView;
admin?: ParticipantRowAdmin;
}) {
const { data: ddragon } = useDdragonManifest();
const location = useLocation();
const historyBackTo = `${location.pathname}${location.search}${location.hash}`;
const [confirmingRemove, setConfirmingRemove] = useState(false);
const handleMainChange = (next: Position) => {
if (!admin) return;
const sub =
next === participant.subPosition
? participant.mainPosition
: participant.subPosition;
admin.onChangePositions(participant.userId, next, sub);
};
const handleSubChange = (next: Position) => {
if (!admin) return;
const main =
next === participant.mainPosition
? participant.subPosition
: participant.mainPosition;
admin.onChangePositions(participant.userId, main, next);
};
return (
<div className="border-b border-base-content/5 px-3 py-2 last:border-b-0">
<div className="grid grid-cols-[minmax(0,1fr)_64px_58px] items-center gap-x-2">
<Link
to={`/users/${participant.userId}/history`}
state={{ backTo: historyBackTo }}
className="flex min-w-0 items-center gap-2 group"
>
<div className="h-8 w-8 shrink-0 overflow-hidden bg-base-content/10">
<img
src={profileIconUrl(ddragon, participant.profileIconId)}
alt=""
className="h-full w-full object-cover"
loading="lazy"
/>
</div>
<div className="min-w-0">
<span className="block break-words text-sm font-medium leading-tight text-base-content transition-colors group-hover:text-primary">
{participant.summonerName}
</span>
<span className="inline-flex items-center gap-1 text-xs leading-tight text-base-content/25">
#{participant.tag}
{participant.excluded && (
<span className="border border-amber-500/20 bg-amber-500/10 px-1 text-xs font-bold text-amber-500">
제외
</span>
)}
</span>
</div>
</Link>
<TierCell participant={participant} />
<PreferredPositionText
mainPosition={participant.mainPosition}
subPosition={participant.subPosition}
/>
</div>
{admin && (
<div className="mt-2 flex flex-wrap items-center justify-between gap-x-3 gap-y-2 border-t border-base-content/5 pt-2">
<span className="inline-flex items-center gap-1 whitespace-nowrap">
<PositionSelect
value={participant.mainPosition}
disabled={admin.isUpdating}
onChange={handleMainChange}
/>
<span className="text-xs text-base-content/35">/</span>
<PositionSelect
value={participant.subPosition}
sub
disabled={admin.isUpdating}
onChange={handleSubChange}
/>
</span>
{confirmingRemove ? (
<span className="inline-flex items-center gap-2 whitespace-nowrap">
<button
type="button"
disabled={admin.isRemoving}
onClick={() => admin.onRemove(participant.userId)}
className="text-xs font-bold text-red-400 hover:text-red-300 disabled:opacity-50"
>
{admin.isRemoving ? "제외 중..." : "확인"}
</button>
<button
type="button"
onClick={() => setConfirmingRemove(false)}
className="text-xs text-base-content/35 hover:text-base-content/60"
>
취소
</button>
</span>
) : (
<button
type="button"
onClick={() => setConfirmingRemove(true)}
className="text-xs font-bold text-base-content/35 hover:text-red-400"
>
제외
</button>
)}
</div>
)}
</div>
);
}
function ParticipantTable({ function ParticipantTable({
participants, participants,
maxParticipants, maxParticipants,
@@ -533,31 +698,31 @@ function ParticipantTable({
return ( return (
<div className="border border-base-content/10 bg-base-100 overflow-hidden"> <div className="border border-base-content/10 bg-base-100 overflow-hidden">
<div className="px-4 py-2.5 border-b border-base-content/10 bg-base-200/40 flex items-center justify-between gap-3"> <div className="px-4 py-2.5 border-b border-base-content/10 bg-base-200/40 flex items-center justify-between gap-3">
<h3 className="text-[11px] font-bold uppercase tracking-wider text-base-content/40"> <h3 className="text-xs font-bold uppercase tracking-wider text-base-content/40">
참가자 ({participants.length}/{maxParticipants}) 참가자 ({participants.length}/{maxParticipants})
</h3> </h3>
<button <button
type="button" type="button"
onClick={onJoin} onClick={onJoin}
disabled={!canJoin || joined || isJoining} disabled={!canJoin || joined || isJoining}
className="btn btn-primary btn-xs px-4 text-[11px] font-semibold disabled:opacity-40" className="btn btn-primary btn-xs px-4 text-xs font-semibold disabled:opacity-40"
> >
{joined ? "참가 완료" : isJoining ? "신청 중..." : "참가 신청"} {joined ? "참가 완료" : isJoining ? "신청 중..." : "참가 신청"}
</button> </button>
</div> </div>
<div className="border-b border-base-content/10 bg-base-100 px-4 py-2.5"> <div className="border-b border-base-content/10 bg-base-100 px-4 py-2.5">
<div className="flex flex-wrap items-center gap-x-3 gap-y-2"> <div className="flex flex-wrap items-center gap-x-2 gap-y-2">
<div className="inline-flex items-center gap-1"> <div className="inline-flex items-center gap-1">
<button <button
type="button" type="button"
onClick={() => setPositionFilter(ALL_PARTICIPANT_FILTER)} onClick={() => setPositionFilter(ALL_PARTICIPANT_FILTER)}
className={`inline-flex h-8 items-center px-2.5 text-[11px] font-semibold border transition-colors ${ className={`inline-flex h-8 w-[3.75rem] items-center justify-center px-1 text-xs font-semibold border transition-colors ${
positionFilter === ALL_PARTICIPANT_FILTER positionFilter === ALL_PARTICIPANT_FILTER
? "border-primary/30 bg-primary/5 text-primary" ? "border-primary/30 bg-primary/5 text-primary"
: "border-base-content/10 text-base-content/40 hover:text-base-content/70" : "border-base-content/10 text-base-content/40 hover:text-base-content/70"
}`} }`}
> >
전체 ({participants.length}) 전체<span className="tabular-nums">({participants.length})</span>
</button> </button>
{POSITION_ORDER.map((position) => { {POSITION_ORDER.map((position) => {
const active = positionFilter === position; const active = positionFilter === position;
@@ -574,27 +739,20 @@ function ParticipantTable({
active ? ALL_PARTICIPANT_FILTER : position, active ? ALL_PARTICIPANT_FILTER : position,
) )
} }
className={`inline-flex h-8 items-center gap-1 px-2 text-[11px] font-semibold border transition-colors ${ className={`inline-flex h-8 w-[3.75rem] items-center justify-center px-1 text-xs font-semibold border transition-colors ${
active active
? "border-primary/30 bg-primary/5 text-primary" ? "border-primary/30 bg-primary/5 text-primary"
: "border-base-content/10 text-base-content/40 hover:text-base-content/70" : "border-base-content/10 text-base-content/40 hover:text-base-content/70"
}`} }`}
> >
<img {positionLabel[position]}
src={positionIcon[position]}
alt=""
className="h-3.5 w-3.5 object-contain"
/>
<span className="hidden sm:inline">
{positionLabel[position]}
</span>
<span className="tabular-nums">({count})</span> <span className="tabular-nums">({count})</span>
</button> </button>
); );
})} })}
</div> </div>
<select <select
className="h-8 border border-base-content/10 bg-base-100 px-2 text-xs text-base-content focus:border-primary/30 focus:outline-none" className="h-8 w-32 shrink-0 border border-base-content/10 bg-base-100 px-2 text-xs text-base-content focus:border-primary/30 focus:outline-none"
value={tierFilter} value={tierFilter}
onChange={(event) => setTierFilter(event.target.value)} onChange={(event) => setTierFilter(event.target.value)}
> >
@@ -606,14 +764,11 @@ function ParticipantTable({
</option> </option>
))} ))}
</select> </select>
<div className="ml-auto flex items-center gap-2 text-[11px] text-base-content/35"> <div className="ml-auto flex min-w-[6.5rem] shrink-0 items-center justify-end gap-1 whitespace-nowrap text-xs text-base-content/35">
<span>
{filteredParticipants.length}/{participants.length}명
</span>
{isFiltered && ( {isFiltered && (
<button <button
type="button" type="button"
className="btn btn-ghost btn-xs h-8 min-h-8 px-2 text-[11px] text-base-content/40" className="btn btn-ghost btn-xs h-8 min-h-8 shrink-0 px-1 text-xs text-base-content/40"
onClick={() => { onClick={() => {
setPositionFilter(ALL_PARTICIPANT_FILTER); setPositionFilter(ALL_PARTICIPANT_FILTER);
setTierFilter(ALL_PARTICIPANT_FILTER); setTierFilter(ALL_PARTICIPANT_FILTER);
@@ -622,20 +777,78 @@ function ParticipantTable({
초기화 초기화
</button> </button>
)} )}
<span className="w-10 shrink-0 text-right tabular-nums">
{filteredParticipants.length}/{participants.length}명
</span>
</div> </div>
</div> </div>
</div> </div>
<div className="overflow-x-auto"> <div className="sm:hidden">
<table className="w-full text-left"> <div className="grid grid-cols-[minmax(0,1fr)_64px_58px] gap-x-2 border-b border-base-content/8 bg-base-200/30 px-3 py-2 text-xs font-semibold uppercase tracking-wider text-base-content/35">
<span>소환사</span>
<span>현재 티어</span>
<span>포지션</span>
</div>
{filteredParticipants.length > 0 ? (
filteredParticipants.map((participant) => (
<ParticipantMobileRow
key={participant.id}
participant={participant}
admin={
canManage
? {
onRemove: onRemoveParticipant,
onChangePositions: onUpdatePositions,
isRemoving: removingUserId === participant.userId,
isUpdating: updatingUserId === participant.userId,
}
: undefined
}
/>
))
) : (
<div className="px-3 py-8 text-center text-sm text-base-content/35">
조건에 맞는 참가자가 없습니다.
</div>
)}
</div>
<div className="hidden overflow-x-auto sm:block">
<table className="w-full min-w-[40rem] table-fixed text-left">
<colgroup>
<col className="w-0 sm:w-[5%]" />
<col className={canManage ? "w-[27%]" : "w-[38%]"} />
<col className={canManage ? "w-[34%]" : "w-[34%]"} />
<col className={canManage ? "w-[22%]" : "w-[23%]"} />
{canManage && <col className="w-[12%]" />}
</colgroup>
<thead> <thead>
<tr className="border-b border-base-content/10 bg-base-200/40 text-[11px] uppercase tracking-wider text-base-content/35 font-semibold"> <tr className="border-b border-base-content/10 bg-base-200/40 text-xs uppercase tracking-wider text-base-content/35 font-semibold">
<th className="py-2 px-3 w-8">#</th> <th className="hidden py-2 px-3 w-0 sm:table-cell sm:w-[5%]">
<th className="py-2 px-3">소환사</th> #
<th className="py-2 px-3">현재 티어</th> </th>
<th className="py-2 px-3">주 포지션</th> <th
<th className="py-2 px-3">부 포지션</th> className={
canManage ? "py-2 px-3 w-[27%]" : "py-2 px-3 w-[38%]"
}
>
소환사
</th>
<th
className={
canManage ? "py-2 px-3 w-[34%]" : "py-2 px-3 w-[34%]"
}
>
현재 티어
</th>
<th
className={
canManage ? "py-2 px-3 w-[22%]" : "py-2 px-3 w-[23%]"
}
>
포지션
</th>
{canManage && ( {canManage && (
<th className="py-2 px-3 w-20 min-w-[5rem] whitespace-nowrap text-right"> <th className="py-2 px-3 w-[12%] min-w-[5rem] whitespace-nowrap text-right">
관리 관리
</th> </th>
)} )}
@@ -663,7 +876,7 @@ function ParticipantTable({
) : ( ) : (
<tr> <tr>
<td <td
colSpan={canManage ? 6 : 5} colSpan={canManage ? 5 : 4}
className="px-3 py-8 text-center text-sm text-base-content/35" className="px-3 py-8 text-center text-sm text-base-content/35"
> >
조건에 맞는 참가자가 없습니다. 조건에 맞는 참가자가 없습니다.
@@ -675,7 +888,7 @@ function ParticipantTable({
</div> </div>
{participants.length < maxParticipants && ( {participants.length < maxParticipants && (
<div className="px-4 py-2.5 border-t border-base-content/5 text-center bg-base-200/20"> <div className="px-4 py-2.5 border-t border-base-content/5 text-center bg-base-200/20">
<span className="text-[11px] text-base-content/25"> <span className="text-xs text-base-content/25">
{maxParticipants - participants.length}자리 남음 {maxParticipants - participants.length}자리 남음
</span> </span>
</div> </div>
@@ -710,19 +923,32 @@ function TeamCard({
{team.name} {team.name}
</span> </span>
{isWinner && ( {isWinner && (
<span className="inline-flex items-center text-[10px] font-bold px-1.5 py-0.5 bg-amber-500/15 text-amber-400 border border-amber-500/20"> <span className="inline-flex items-center text-xs font-bold px-1.5 py-0.5 bg-accent/15 text-amber-400 border border-accent/20">
WIN WIN
</span> </span>
)} )}
</div> </div>
<Link <Link
to={`/match/${matchId}/team/${team.teamIndex}`} to={`/match/${matchId}/team/${team.teamIndex}`}
className="text-[10px] font-bold text-base-content/35 hover:text-primary" className="text-xs font-bold text-base-content/35 hover:text-primary"
> >
진행 페이지 진행 페이지
</Link> </Link>
</div> </div>
<table className="w-full table-fixed text-left"> <div className="sm:hidden">
<div className="grid grid-cols-[minmax(0,1fr)_64px_58px] gap-x-2 border-b border-base-content/8 bg-base-200/30 px-3 py-2 text-xs font-semibold uppercase tracking-wider text-base-content/35">
<span>소환사</span>
<span>현재 티어</span>
<span>포지션</span>
</div>
{team.participants.map((participant) => (
<TeamParticipantMobileRow
key={participant.id}
participant={participant}
/>
))}
</div>
<table className="hidden w-full table-fixed text-left sm:table">
<colgroup> <colgroup>
<col className="w-11" /> <col className="w-11" />
<col /> <col />
@@ -730,8 +956,8 @@ function TeamCard({
<col className="w-32" /> <col className="w-32" />
</colgroup> </colgroup>
<thead> <thead>
<tr className="border-b border-base-content/8 bg-base-200/30 text-[11px] uppercase tracking-wider text-base-content/35 font-semibold"> <tr className="border-b border-base-content/8 bg-base-200/30 text-xs uppercase tracking-wider text-base-content/35 font-semibold">
<th className="py-2 px-3 w-8">#</th> <th className="hidden py-2 px-3 w-8 sm:table-cell">#</th>
<th className="py-2 px-3">소환사</th> <th className="py-2 px-3">소환사</th>
<th className="py-2 px-3">현재 티어</th> <th className="py-2 px-3">현재 티어</th>
<th className="py-2 px-3">포지션</th> <th className="py-2 px-3">포지션</th>
@@ -762,7 +988,7 @@ function SideCard({
return ( return (
<div className="border border-base-content/10 bg-base-100 overflow-hidden"> <div className="border border-base-content/10 bg-base-100 overflow-hidden">
<div className="px-4 py-2 border-b border-base-content/10 bg-base-200/40"> <div className="px-4 py-2 border-b border-base-content/10 bg-base-200/40">
<h3 className="text-[11px] font-bold uppercase tracking-wider text-base-content/40"> <h3 className="text-xs font-bold uppercase tracking-wider text-base-content/40">
{title} {title}
</h3> </h3>
</div> </div>
@@ -811,13 +1037,13 @@ function TournamentCodeDisplay({ slot }: { slot: TournamentCodeSlotView }) {
: "border-primary/20 bg-primary/5 text-base-content" : "border-primary/20 bg-primary/5 text-base-content"
}`} }`}
> >
<code className="font-mono text-[12px] font-bold truncate"> <code className="font-mono text-xs font-bold truncate">
{expired ? "코드 만료" : slot.code} {expired ? "코드 만료" : slot.code}
</code> </code>
{slot.code && !expired && ( {slot.code && !expired && (
<button <button
type="button" type="button"
className="ml-auto text-[10px] px-1.5 py-0.5 border border-base-content/10 text-base-content/45 hover:text-primary" className="ml-auto text-xs px-1.5 py-0.5 border border-base-content/10 text-base-content/45 hover:text-primary"
onClick={copyCode} onClick={copyCode}
> >
{copied ? "복사됨" : "복사"} {copied ? "복사됨" : "복사"}
@@ -825,7 +1051,7 @@ function TournamentCodeDisplay({ slot }: { slot: TournamentCodeSlotView }) {
)} )}
</div> </div>
<div <div
className={`mt-1 text-[10px] ${ className={`mt-1 text-xs ${
expired || expiringSoon ? "text-amber-500" : "text-base-content/30" expired || expiringSoon ? "text-amber-500" : "text-base-content/30"
}`} }`}
> >
@@ -842,7 +1068,7 @@ function TournamentCodeDisplay({ slot }: { slot: TournamentCodeSlotView }) {
function TournamentCodeList({ slots }: { slots: TournamentCodeSlotView[] }) { function TournamentCodeList({ slots }: { slots: TournamentCodeSlotView[] }) {
if (slots.length === 0) { if (slots.length === 0) {
return ( return (
<div className="border border-dashed border-base-content/10 px-3 py-3 text-[11px] text-base-content/30"> <div className="border border-dashed border-base-content/10 px-3 py-3 text-xs text-base-content/30">
아직 배정된 코드가 없습니다. 아직 배정된 코드가 없습니다.
</div> </div>
); );
@@ -852,10 +1078,10 @@ function TournamentCodeList({ slots }: { slots: TournamentCodeSlotView[] }) {
<div className="space-y-2"> <div className="space-y-2">
{slots.map((slot) => ( {slots.map((slot) => (
<div key={slot.gameNumber} className="flex items-start gap-2"> <div key={slot.gameNumber} className="flex items-start gap-2">
<span className="text-[11px] font-bold text-base-content/40 w-20 shrink-0 pt-1.5"> <span className="text-xs font-bold text-base-content/40 w-20 shrink-0 pt-1.5">
{slot.gameNumber}경기 {slot.gameNumber}경기
{(slot.teamAIndex > 1 || slot.teamBIndex > 2) && ( {(slot.teamAIndex > 1 || slot.teamBIndex > 2) && (
<span className="block text-[10px] font-normal text-base-content/25"> <span className="block text-xs font-normal text-base-content/25">
{teamIndexLabel(slot.teamAIndex)} vs{" "} {teamIndexLabel(slot.teamAIndex)} vs{" "}
{teamIndexLabel(slot.teamBIndex)} {teamIndexLabel(slot.teamBIndex)}
</span> </span>
@@ -864,7 +1090,7 @@ function TournamentCodeList({ slots }: { slots: TournamentCodeSlotView[] }) {
{slot.code ? ( {slot.code ? (
<TournamentCodeDisplay slot={slot} /> <TournamentCodeDisplay slot={slot} />
) : ( ) : (
<span className="text-[11px] text-base-content/30 border border-dashed border-base-content/10 px-2 py-2 flex-1"> <span className="text-xs text-base-content/30 border border-dashed border-base-content/10 px-2 py-2 flex-1">
발급 대기 중... 운영자가 코드를 채우면 자동으로 붙습니다. 발급 대기 중... 운영자가 코드를 채우면 자동으로 붙습니다.
</span> </span>
)} )}
@@ -898,7 +1124,7 @@ function PoolStatsHint({ enabled }: { enabled: boolean }) {
const expiringSoon = statsQuery.data?.expiringSoon ?? 0; const expiringSoon = statsQuery.data?.expiringSoon ?? 0;
return ( return (
<div className="mt-3 border-t border-base-content/8 pt-3 text-[11px]"> <div className="mt-3 border-t border-base-content/8 pt-3 text-xs">
<div className={available < 5 ? "text-red-400" : "text-base-content/35"}> <div className={available < 5 ? "text-red-400" : "text-base-content/35"}>
풀 잔여 {available}개 풀 잔여 {available}개
{expiringSoon > 0 ? ` · 만료 임박 ${expiringSoon}개` : ""} {expiringSoon > 0 ? ` · 만료 임박 ${expiringSoon}개` : ""}
@@ -1073,13 +1299,13 @@ function RoundRobinStandingsTable({ match }: { match: MatchDetailView }) {
<h3 className="text-xs font-black text-base-content/65"> <h3 className="text-xs font-black text-base-content/65">
라운드로빈 순위 라운드로빈 순위
</h3> </h3>
<p className="mt-0.5 text-[11px] text-base-content/35"> <p className="mt-0.5 text-xs text-base-content/35">
{standings.length}팀 · {match.result?.games.length ?? 0}경기 완료 {standings.length}팀 · {match.result?.games.length ?? 0}경기 완료
</p> </p>
</div> </div>
{match.result?.winner && ( {match.result?.winner && (
<div className="text-right"> <div className="text-right">
<div className="text-[10px] font-bold uppercase tracking-wider text-base-content/35"> <div className="text-xs font-bold uppercase tracking-wider text-base-content/35">
1위 1위
</div> </div>
<div className="text-sm font-black text-amber-400"> <div className="text-sm font-black text-amber-400">
@@ -1090,7 +1316,7 @@ function RoundRobinStandingsTable({ match }: { match: MatchDetailView }) {
</div> </div>
<div className="mt-4 overflow-x-auto border border-base-content/8"> <div className="mt-4 overflow-x-auto border border-base-content/8">
<table className="min-w-[760px] w-full text-xs"> <table className="min-w-[760px] w-full text-xs">
<thead className="bg-base-100 text-[11px] text-base-content/45"> <thead className="bg-base-100 text-xs text-base-content/45">
<tr className="border-b border-base-content/8"> <tr className="border-b border-base-content/8">
<th className="h-9 px-3 text-left font-semibold">팀 순위</th> <th className="h-9 px-3 text-left font-semibold">팀 순위</th>
<th className="h-9 px-3 text-center font-semibold bg-primary/5 text-primary"> <th className="h-9 px-3 text-center font-semibold bg-primary/5 text-primary">
@@ -1198,7 +1424,7 @@ function MatchResultPanel({ match }: { match: MatchDetailView }) {
<div className="text-3xl font-black tabular-nums"> <div className="text-3xl font-black tabular-nums">
{primarySeries.teamAWins} {primarySeries.teamAWins}
</div> </div>
<div className="text-[10px] uppercase tracking-wider mt-0.5 font-semibold"> <div className="text-xs uppercase tracking-wider mt-0.5 font-semibold">
{resolveMatchTeamName(match, primarySeries.teamAIndex)} {resolveMatchTeamName(match, primarySeries.teamAIndex)}
</div> </div>
</div> </div>
@@ -1211,13 +1437,13 @@ function MatchResultPanel({ match }: { match: MatchDetailView }) {
<div className="text-3xl font-black tabular-nums"> <div className="text-3xl font-black tabular-nums">
{primarySeries.teamBWins} {primarySeries.teamBWins}
</div> </div>
<div className="text-[10px] uppercase tracking-wider mt-0.5 font-semibold"> <div className="text-xs uppercase tracking-wider mt-0.5 font-semibold">
{resolveMatchTeamName(match, primarySeries.teamBIndex)} {resolveMatchTeamName(match, primarySeries.teamBIndex)}
</div> </div>
</div> </div>
</div> </div>
)} )}
<div className="text-center mt-3 text-[11px] font-bold text-amber-400 uppercase tracking-wide"> <div className="text-center mt-3 text-xs font-bold text-amber-400 uppercase tracking-wide">
{match.result.winner {match.result.winner
? `${match.result.winner} 승리` ? `${match.result.winner} 승리`
: `결과 수집 중 · ${match.result.games.length}/${maxGameNumber}경기`} : `결과 수집 중 · ${match.result.games.length}/${maxGameNumber}경기`}
@@ -1323,9 +1549,8 @@ export default function MatchDetailPage() {
const [manualRiotMatchId, setManualRiotMatchId] = useState(""); const [manualRiotMatchId, setManualRiotMatchId] = useState("");
const pollTournamentResultMutation = const pollTournamentResultMutation =
usePollTournamentResult(DEFAULT_COMMUNITY_ID); usePollTournamentResult(DEFAULT_COMMUNITY_ID);
const collectResultByWindowMutation = useCollectTournamentResultByWindow( const collectResultByWindowMutation =
DEFAULT_COMMUNITY_ID, useCollectTournamentResultByWindow(DEFAULT_COMMUNITY_ID);
);
const collectResultByRiotMatchMutation = const collectResultByRiotMatchMutation =
useCollectTournamentResultByRiotMatch(DEFAULT_COMMUNITY_ID); useCollectTournamentResultByRiotMatch(DEFAULT_COMMUNITY_ID);
@@ -1672,7 +1897,7 @@ export default function MatchDetailPage() {
{match.title} {match.title}
</h1> </h1>
<span <span
className={`inline-flex items-center text-[11px] font-semibold px-1.5 py-0.5 border ${si.cls}`} className={`inline-flex items-center text-xs font-semibold px-1.5 py-0.5 border ${si.cls}`}
> >
{si.label} {si.label}
</span> </span>
@@ -1689,7 +1914,7 @@ export default function MatchDetailPage() {
{match.participants.length}/{match.maxParticipants}명 {match.participants.length}/{match.maxParticipants}명
</span> </span>
<span className="text-base-content/15">|</span> <span className="text-base-content/15">|</span>
<span className="inline-flex items-center text-[11px] px-1.5 py-0.5 border border-base-content/10 text-base-content/40"> <span className="inline-flex items-center text-xs px-1.5 py-0.5 border border-base-content/10 text-base-content/40">
{match.map} {match.map}
</span> </span>
</div> </div>
@@ -1775,7 +2000,7 @@ export default function MatchDetailPage() {
{isCheckingPermissions ? ( {isCheckingPermissions ? (
<div className="border border-base-content/10 bg-base-100 p-4"> <div className="border border-base-content/10 bg-base-100 p-4">
<h3 className="text-[11px] font-bold uppercase tracking-wider text-base-content/40"> <h3 className="text-xs font-bold uppercase tracking-wider text-base-content/40">
권한 확인 중 권한 확인 중
</h3> </h3>
<p className="mt-1 text-xs text-base-content/40"> <p className="mt-1 text-xs text-base-content/40">
@@ -1785,7 +2010,7 @@ export default function MatchDetailPage() {
) : canManageAuction ? ( ) : canManageAuction ? (
<div className="border border-base-content/10 bg-base-100 p-4 space-y-3"> <div className="border border-base-content/10 bg-base-100 p-4 space-y-3">
<div> <div>
<h3 className="text-[11px] font-bold uppercase tracking-wider text-base-content/40"> <h3 className="text-xs font-bold uppercase tracking-wider text-base-content/40">
경매 시작 경매 시작
</h3> </h3>
<p className="mt-1 text-xs text-base-content/40"> <p className="mt-1 text-xs text-base-content/40">
@@ -1793,7 +2018,7 @@ export default function MatchDetailPage() {
팀장을 지정합니다. 팀장을 지정합니다.
</p> </p>
{waitingParticipantCount > 0 && ( {waitingParticipantCount > 0 && (
<p className="mt-1 text-[11px] text-amber-500"> <p className="mt-1 text-xs text-amber-500">
{waitingParticipantCount}명은 10명 단위에 맞지 않아 이번 {waitingParticipantCount}명은 10명 단위에 맞지 않아 이번
경매에서 제외됩니다. 경매에서 제외됩니다.
</p> </p>
@@ -1930,7 +2155,7 @@ export default function MatchDetailPage() {
); );
}} }}
/> />
<span className="shrink-0 px-2 text-[11px] text-base-content/30"> <span className="shrink-0 px-2 text-xs text-base-content/30">
초 초
</span> </span>
</div> </div>
@@ -1962,11 +2187,11 @@ export default function MatchDetailPage() {
); );
}} }}
/> />
<span className="shrink-0 px-2 text-[11px] text-base-content/30"> <span className="shrink-0 px-2 text-xs text-base-content/30">
초 초
</span> </span>
</div> </div>
<span className="mt-1 block text-[11px] text-base-content/30"> <span className="mt-1 block text-xs text-base-content/30">
남은 시간이 이 값보다 적을 때 입찰하면 이 시간까지 남은 시간이 이 값보다 적을 때 입찰하면 이 시간까지
늘어납니다. 늘어납니다.
</span> </span>
@@ -1992,7 +2217,7 @@ export default function MatchDetailPage() {
</div> </div>
{topTierThreshold === "MANUAL" && ( {topTierThreshold === "MANUAL" && (
<div className="border border-base-content/10 bg-base-200/20 p-3"> <div className="border border-base-content/10 bg-base-200/20 p-3">
<div className="mb-2 text-[11px] font-bold uppercase tracking-wider text-base-content/35"> <div className="mb-2 text-xs font-bold uppercase tracking-wider text-base-content/35">
우선 등장 선수 우선 등장 선수
</div> </div>
<div className="max-h-48 overflow-y-auto space-y-1"> <div className="max-h-48 overflow-y-auto space-y-1">
@@ -2112,9 +2337,9 @@ export default function MatchDetailPage() {
{match.schedule.map((item, index) => ( {match.schedule.map((item, index) => (
<li <li
key={index} key={index}
className="flex items-start gap-2.5 text-[13px]" className="flex items-start gap-2.5 text-sm"
> >
<span className="font-mono text-[11px] text-base-content/30 w-11 shrink-0 pt-px"> <span className="font-mono text-xs text-base-content/30 w-11 shrink-0 pt-px">
{item.time} {item.time}
</span> </span>
<span className="text-base-content/60">{item.label}</span> <span className="text-base-content/60">{item.label}</span>
@@ -2138,7 +2363,7 @@ export default function MatchDetailPage() {
<SideCard title="결과 수집"> <SideCard title="결과 수집">
<div className="space-y-4"> <div className="space-y-4">
<div> <div>
<div className="mb-2 text-[11px] font-bold text-base-content/45"> <div className="mb-2 text-xs font-bold text-base-content/45">
토너먼트 코드 토너먼트 코드
</div> </div>
<button <button
@@ -2154,11 +2379,11 @@ export default function MatchDetailPage() {
</div> </div>
<div className="border-t border-base-content/8 pt-4"> <div className="border-t border-base-content/8 pt-4">
<div className="mb-2 text-[11px] font-bold text-base-content/45"> <div className="mb-2 text-xs font-bold text-base-content/45">
시간 범위 시간 범위
</div> </div>
<div className="space-y-2"> <div className="space-y-2">
<label className="block text-[10px] text-base-content/35"> <label className="block text-xs text-base-content/35">
시작 시작
<input <input
type="datetime-local" type="datetime-local"
@@ -2167,10 +2392,10 @@ export default function MatchDetailPage() {
onChange={(event) => onChange={(event) =>
setManualResultStartTime(event.target.value) setManualResultStartTime(event.target.value)
} }
className="mt-1 w-full border border-base-content/10 bg-transparent px-2 py-2 text-[11px] text-base-content focus:outline-none focus:border-primary/30" className="mt-1 w-full border border-base-content/10 bg-transparent px-2 py-2 text-xs text-base-content focus:outline-none focus:border-primary/30"
/> />
</label> </label>
<label className="block text-[10px] text-base-content/35"> <label className="block text-xs text-base-content/35">
종료 종료
<input <input
type="datetime-local" type="datetime-local"
@@ -2179,7 +2404,7 @@ export default function MatchDetailPage() {
onChange={(event) => onChange={(event) =>
setManualResultEndTime(event.target.value) setManualResultEndTime(event.target.value)
} }
className="mt-1 w-full border border-base-content/10 bg-transparent px-2 py-2 text-[11px] text-base-content focus:outline-none focus:border-primary/30" className="mt-1 w-full border border-base-content/10 bg-transparent px-2 py-2 text-xs text-base-content focus:outline-none focus:border-primary/30"
/> />
</label> </label>
<button <button
@@ -2199,7 +2424,7 @@ export default function MatchDetailPage() {
{formatManualCollectSummary( {formatManualCollectSummary(
collectResultByWindowMutation.data, collectResultByWindowMutation.data,
) && ( ) && (
<div className="text-[10px] text-base-content/35"> <div className="text-xs text-base-content/35">
{formatManualCollectSummary( {formatManualCollectSummary(
collectResultByWindowMutation.data, collectResultByWindowMutation.data,
)} )}
@@ -2209,7 +2434,7 @@ export default function MatchDetailPage() {
</div> </div>
<div className="border-t border-base-content/8 pt-4"> <div className="border-t border-base-content/8 pt-4">
<div className="mb-2 text-[11px] font-bold text-base-content/45"> <div className="mb-2 text-xs font-bold text-base-content/45">
Riot Match ID Riot Match ID
</div> </div>
<div className="space-y-2"> <div className="space-y-2">
@@ -2220,7 +2445,7 @@ export default function MatchDetailPage() {
setManualRiotMatchId(event.target.value) setManualRiotMatchId(event.target.value)
} }
placeholder="KR_1234567890" placeholder="KR_1234567890"
className="w-full border border-base-content/10 bg-transparent px-2 py-2 text-[11px] text-base-content focus:outline-none focus:border-primary/30" className="w-full border border-base-content/10 bg-transparent px-2 py-2 text-xs text-base-content focus:outline-none focus:border-primary/30"
/> />
<button <button
type="button" type="button"
@@ -2238,7 +2463,7 @@ export default function MatchDetailPage() {
{formatManualCollectSummary( {formatManualCollectSummary(
collectResultByRiotMatchMutation.data, collectResultByRiotMatchMutation.data,
) && ( ) && (
<div className="text-[10px] text-base-content/35"> <div className="text-xs text-base-content/35">
{formatManualCollectSummary( {formatManualCollectSummary(
collectResultByRiotMatchMutation.data, collectResultByRiotMatchMutation.data,
)} )}
@@ -2256,9 +2481,9 @@ export default function MatchDetailPage() {
{match.prizes.map((prize, index) => ( {match.prizes.map((prize, index) => (
<li <li
key={index} key={index}
className="flex items-start gap-2 text-[13px] text-base-content/60" className="flex items-start gap-2 text-sm text-base-content/60"
> >
<span className="text-amber-400 shrink-0 text-xs">▸</span> <span className="text-accent shrink-0 text-xs">▸</span>
<span>{prize}</span> <span>{prize}</span>
</li> </li>
))} ))}
@@ -2272,9 +2497,9 @@ export default function MatchDetailPage() {
{match.notices.map((notice, index) => ( {match.notices.map((notice, index) => (
<li <li
key={index} key={index}
className="flex items-start gap-2 text-[13px] text-base-content/60" className="flex items-start gap-2 text-sm text-base-content/60"
> >
<span className="text-base-content/20 shrink-0">•</span> <span className="text-info shrink-0 font-bold">•</span>
<span>{notice}</span> <span>{notice}</span>
</li> </li>
))} ))}
+21 -21
View File
@@ -64,10 +64,10 @@ function SummonerStatsSummary({
return ( return (
<div className="ml-auto flex min-w-[148px] shrink-0 flex-col items-end text-right leading-tight"> <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"> <div className="text-xs font-black text-primary">
{assignedPosition ? positionLabel[assignedPosition] : "-"} {assignedPosition ? positionLabel[assignedPosition] : "-"}
</div> </div>
<div className="mt-1 flex items-center justify-end gap-2 text-[10px] font-black text-base-content/35"> <div className="mt-1 flex items-center justify-end gap-2 text-xs font-black text-base-content/35">
<span className="inline-flex items-center gap-1"> <span className="inline-flex items-center gap-1">
<span>SOLO</span> <span>SOLO</span>
<RankBadge tier={soloTier} size="sm" tooltipPlacement="left" /> <RankBadge tier={soloTier} size="sm" tooltipPlacement="left" />
@@ -129,12 +129,12 @@ function ParticipantLine({
{name} {name}
</span> </span>
{isCaptain && ( {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 className="shrink-0 border border-accent/20 bg-accent/10 px-1.5 py-0.5 text-xs font-bold text-amber-500">
팀장 팀장
</span> </span>
)} )}
</div> </div>
<div className="text-[11px] text-base-content/30">#{tag}</div> <div className="text-xs text-base-content/30">#{tag}</div>
</div> </div>
<SummonerStatsSummary <SummonerStatsSummary
assignedPosition={assignedPosition} assignedPosition={assignedPosition}
@@ -218,7 +218,7 @@ function UpcomingGameCard({
<div className="flex items-center justify-between gap-2"> <div className="flex items-center justify-between gap-2">
<div className="flex items-center gap-2"> <div className="flex items-center gap-2">
<span <span
className={`border px-2 py-1 text-[11px] font-black ${ className={`border px-2 py-1 text-xs font-black ${
isNext isNext
? "border-primary/25 bg-primary/10 text-primary" ? "border-primary/25 bg-primary/10 text-primary"
: "border-base-content/10 bg-base-content/5 text-base-content/55" : "border-base-content/10 bg-base-content/5 text-base-content/55"
@@ -226,14 +226,14 @@ function UpcomingGameCard({
> >
{isNext ? "다음 경기" : `${slot.gameNumber}경기`} {isNext ? "다음 경기" : `${slot.gameNumber}경기`}
</span> </span>
<span className="text-[11px] font-semibold text-base-content/35"> <span className="text-xs font-semibold text-base-content/35">
{sideShortLabel(ourSide)} {sideShortLabel(ourSide)}
</span> </span>
</div> </div>
{finished ? ( {finished ? (
<div className="flex items-center gap-2"> <div className="flex items-center gap-2">
<span <span
className={`border px-2 py-1 text-[11px] font-black ${resultBadgeClass(won)}`} className={`border px-2 py-1 text-xs font-black ${resultBadgeClass(won)}`}
> >
{won ? "승리" : "패배"} {won ? "승리" : "패배"}
</span> </span>
@@ -274,12 +274,12 @@ function UpcomingGameCard({
{ourTeamName} {ourTeamName}
</div> </div>
{ourCaptainName && ( {ourCaptainName && (
<div className="mt-1 truncate text-[11px] text-base-content/35"> <div className="mt-1 truncate text-xs text-base-content/35">
팀장 {ourCaptainName} 팀장 {ourCaptainName}
</div> </div>
)} )}
</div> </div>
<div className="pt-0.5 text-[10px] font-black uppercase tracking-wider text-base-content/25"> <div className="pt-0.5 text-xs font-black uppercase tracking-wider text-base-content/25">
vs vs
</div> </div>
<div className="min-w-0 text-right"> <div className="min-w-0 text-right">
@@ -287,7 +287,7 @@ function UpcomingGameCard({
{opponentTeamName} {opponentTeamName}
</div> </div>
{opponentCaptainName && ( {opponentCaptainName && (
<div className="mt-1 truncate text-[11px] text-base-content/35"> <div className="mt-1 truncate text-xs text-base-content/35">
팀장 {opponentCaptainName} 팀장 {opponentCaptainName}
</div> </div>
)} )}
@@ -295,25 +295,25 @@ function UpcomingGameCard({
</div> </div>
<div className="mt-4 border border-base-content/8 bg-base-content/[0.02] px-3 py-2"> <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 className="text-xs font-black uppercase tracking-wider text-base-content/35">
토너먼트 코드 토너먼트 코드
</div> </div>
<div className="mt-1 flex items-center gap-2"> <div className="mt-1 flex items-center gap-2">
{slot.code ? ( {slot.code ? (
<> <>
<code className="min-w-0 flex-1 truncate font-mono text-[12px] font-black text-primary"> <code className="min-w-0 flex-1 truncate font-mono text-xs font-black text-primary">
{slot.code} {slot.code}
</code> </code>
<button <button
type="button" type="button"
className="border border-base-content/10 px-2 py-1 text-[10px] font-bold text-base-content/45 hover:text-primary" className="border border-base-content/10 px-2 py-1 text-xs font-bold text-base-content/45 hover:text-primary"
onClick={handleCopy} onClick={handleCopy}
> >
{copied ? "복사됨" : "복사"} {copied ? "복사됨" : "복사"}
</button> </button>
</> </>
) : ( ) : (
<span className="text-[12px] font-semibold text-base-content/30"> <span className="text-xs font-semibold text-base-content/30">
발급 대기 발급 대기
</span> </span>
)} )}
@@ -324,14 +324,14 @@ function UpcomingGameCard({
<div className="mt-3 border border-base-content/8 bg-base-content/[0.015]"> <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 className="flex items-center justify-between gap-2 border-b border-base-content/8 px-3 py-2">
<div> <div>
<div className="text-[11px] font-black text-base-content/55"> <div className="text-xs font-black text-base-content/55">
상대팀 멤버 상대팀 멤버
</div> </div>
<div className="mt-0.5 text-[10px] text-base-content/30"> <div className="mt-0.5 text-xs text-base-content/30">
라인 · 티어 라인 · 티어
</div> </div>
</div> </div>
<div className="truncate text-right text-[11px] font-bold text-base-content/45"> <div className="truncate text-right text-xs font-bold text-base-content/45">
{opponentTeamName} {opponentTeamName}
</div> </div>
</div> </div>
@@ -355,7 +355,7 @@ function UpcomingGameCard({
)} )}
{finished && game?.riotMatchId && ( {finished && game?.riotMatchId && (
<div className="mt-2 truncate font-mono text-[10px] text-base-content/25"> <div className="mt-2 truncate font-mono text-xs text-base-content/25">
{game.riotMatchId} {game.riotMatchId}
</div> </div>
)} )}
@@ -395,14 +395,14 @@ function TeamGameCardsSection({
return ( return (
<section className="mb-4 border border-base-content/10 bg-base-100"> <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"> <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"> <h2 className="text-xs font-bold uppercase tracking-wider text-base-content/40">
{title} {title}
</h2> </h2>
<div className="sm:text-right"> <div className="sm:text-right">
<div className="text-sm font-black text-base-content/70"> <div className="text-sm font-black text-base-content/70">
{formatted.date} {formatted.time} {formatted.date} {formatted.time}
</div> </div>
<div className="mt-0.5 text-[11px] font-semibold text-base-content/35"> <div className="mt-0.5 text-xs font-semibold text-base-content/35">
{GAME_MODE_LABEL[match.gameMode]} {GAME_MODE_LABEL[match.gameMode]}
</div> </div>
</div> </div>
@@ -598,7 +598,7 @@ export default function MatchTeamProgressPage() {
<section className="border border-base-content/10 bg-base-100"> <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"> <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 className="text-xs font-bold uppercase tracking-wider text-base-content/40">
팀 구성 팀 구성
</h2> </h2>
</div> </div>
+46 -46
View File
@@ -143,7 +143,7 @@ function FilterButton({
<button <button
type="button" type="button"
onClick={onClick} onClick={onClick}
className={`px-3 py-2 text-[12px] font-semibold border-b-2 transition-colors ${ className={`px-3 py-2 text-xs font-semibold border-b-2 transition-colors ${
active active
? "border-primary text-primary bg-primary/5" ? "border-primary text-primary bg-primary/5"
: "border-transparent text-base-content/45 hover:text-base-content" : "border-transparent text-base-content/45 hover:text-base-content"
@@ -194,14 +194,14 @@ function SummaryCard({
}) { }) {
return ( return (
<div className="border border-base-content/8 bg-base-100 p-4"> <div className="border border-base-content/8 bg-base-100 p-4">
<div className="text-[10px] font-bold uppercase tracking-wider text-base-content/30"> <div className="text-xs font-bold uppercase tracking-wider text-base-content/30">
{label} {label}
</div> </div>
<div className="mt-2 text-2xl font-black text-base-content tabular-nums"> <div className="mt-2 text-2xl font-black text-base-content tabular-nums">
{value} {value}
</div> </div>
{sub && ( {sub && (
<div className="mt-1 text-[11px] text-base-content/40">{sub}</div> <div className="mt-1 text-xs text-base-content/40">{sub}</div>
)} )}
</div> </div>
); );
@@ -231,7 +231,7 @@ function ChampionStatsTable({
<div className="overflow-x-auto"> <div className="overflow-x-auto">
<table className="w-full text-left min-w-[860px]"> <table className="w-full text-left min-w-[860px]">
<thead> <thead>
<tr className="bg-base-200/50 border-b border-base-content/10 text-[11px] text-base-content/35 uppercase tracking-wider"> <tr className="bg-base-200/50 border-b border-base-content/10 text-xs text-base-content/35 uppercase tracking-wider">
<th className="px-3 py-2.5">챔피언</th> <th className="px-3 py-2.5">챔피언</th>
<th className="px-3 py-2.5 text-center">승률</th> <th className="px-3 py-2.5 text-center">승률</th>
<th className="px-3 py-2.5 text-center">게임</th> <th className="px-3 py-2.5 text-center">게임</th>
@@ -262,48 +262,48 @@ function ChampionStatsTable({
championId={row.championId} championId={row.championId}
manifest={manifest} manifest={manifest}
/> />
<span className="text-[13px] font-bold text-base-content"> <span className="text-sm font-bold text-base-content">
{displayName} {displayName}
</span> </span>
</div> </div>
</td> </td>
<td <td
className={`px-3 py-2.5 text-center text-[13px] font-bold ${ratioClass(row.winRate)}`} className={`px-3 py-2.5 text-center text-sm font-bold ${ratioClass(row.winRate)}`}
> >
{row.winRate}% {row.winRate}%
</td> </td>
<td className="px-3 py-2.5 text-center text-[12px] tabular-nums"> <td className="px-3 py-2.5 text-center text-xs tabular-nums">
{row.games} {row.games}
</td> </td>
<td className="px-3 py-2.5 text-center text-[12px] tabular-nums text-base-content/55"> <td className="px-3 py-2.5 text-center text-xs tabular-nums text-base-content/55">
<span className="text-blue-400">{row.wins}</span> /{" "} <span className="text-blue-400">{row.wins}</span> /{" "}
<span className="text-red-400">{row.losses}</span> <span className="text-red-400">{row.losses}</span>
</td> </td>
<td <td
className={`px-3 py-2.5 text-center text-[13px] font-bold tabular-nums ${kdaClass(row.kda)}`} className={`px-3 py-2.5 text-center text-sm font-bold tabular-nums ${kdaClass(row.kda)}`}
> >
{row.kda} {row.kda}
</td> </td>
<td className="px-3 py-2.5 text-center text-[12px] tabular-nums"> <td className="px-3 py-2.5 text-center text-xs tabular-nums">
{row.totalKills} {row.totalKills}
</td> </td>
<td className="px-3 py-2.5 text-center text-[12px] tabular-nums"> <td className="px-3 py-2.5 text-center text-xs tabular-nums">
{row.totalDeaths} {row.totalDeaths}
</td> </td>
<td className="px-3 py-2.5 text-center text-[12px] tabular-nums"> <td className="px-3 py-2.5 text-center text-xs tabular-nums">
{row.totalAssists} {row.totalAssists}
</td> </td>
<td className="px-3 py-2.5 text-center text-[12px] tabular-nums text-base-content/55"> <td className="px-3 py-2.5 text-center text-xs tabular-nums text-base-content/55">
{row.doubleKills}/{row.tripleKills}/{row.quadraKills}/ {row.doubleKills}/{row.tripleKills}/{row.quadraKills}/
{row.pentaKills} {row.pentaKills}
</td> </td>
<td className="px-3 py-2.5 text-center text-[12px] tabular-nums"> <td className="px-3 py-2.5 text-center text-xs tabular-nums">
{row.avgCs} · {row.avgCsPerMin}/m {row.avgCs} · {row.avgCsPerMin}/m
</td> </td>
<td className="px-3 py-2.5 text-center"> <td className="px-3 py-2.5 text-center">
<button <button
type="button" type="button"
className={`text-[11px] px-2 py-1 border ${ className={`text-xs px-2 py-1 border ${
selected selected
? "border-primary/40 bg-primary/10 text-primary" ? "border-primary/40 bg-primary/10 text-primary"
: "border-base-content/10 text-base-content/40 hover:text-base-content" : "border-base-content/10 text-base-content/40 hover:text-base-content"
@@ -374,7 +374,7 @@ function TeamMini({
manifest: DdragonManifest | null | undefined; manifest: DdragonManifest | null | undefined;
}) { }) {
return ( return (
<div className="grid sm:grid-cols-2 gap-2 text-[11px]"> <div className="grid sm:grid-cols-2 gap-2 text-xs">
{match.teams.map((team) => ( {match.teams.map((team) => (
<div <div
key={`${match.matchId}-${team.side}`} key={`${match.matchId}-${team.side}`}
@@ -499,7 +499,7 @@ function DetailStatBar({
}) { }) {
return ( return (
<div> <div>
<div className="flex items-center justify-between gap-2 text-[10px] text-base-content/45"> <div className="flex items-center justify-between gap-2 text-xs text-base-content/45">
<span>{label}</span> <span>{label}</span>
<span className="font-bold text-base-content/70 tabular-nums"> <span className="font-bold text-base-content/70 tabular-nums">
{formatCompactNumber(value)} {formatCompactNumber(value)}
@@ -524,15 +524,15 @@ function TeamHeader({ team }: { team: ApiRecentMatchTeam }) {
<div className="px-3 py-2 flex flex-wrap items-center justify-between gap-2 border-b border-base-content/10"> <div className="px-3 py-2 flex flex-wrap items-center justify-between gap-2 border-b border-base-content/10">
<div className="flex items-center gap-2"> <div className="flex items-center gap-2">
<span <span
className={`text-[11px] font-black uppercase tracking-wider ${sideClass}`} className={`text-xs font-black uppercase tracking-wider ${sideClass}`}
> >
{sideLabel} {sideLabel}
</span> </span>
<span className={`text-[11px] font-black ${resultClass}`}> <span className={`text-xs font-black ${resultClass}`}>
{team.win ? "승리" : "패배"} {team.win ? "승리" : "패배"}
</span> </span>
</div> </div>
<div className="flex items-center gap-3 text-[11px] text-base-content/45"> <div className="flex items-center gap-3 text-xs text-base-content/45">
<span>드래곤 {team.objectives?.dragon ?? 0}</span> <span>드래곤 {team.objectives?.dragon ?? 0}</span>
<span>바론 {team.objectives?.baron ?? 0}</span> <span>바론 {team.objectives?.baron ?? 0}</span>
<span>타워 {team.objectives?.tower ?? 0}</span> <span>타워 {team.objectives?.tower ?? 0}</span>
@@ -565,7 +565,7 @@ function ParticipantRow({
return ( return (
<div <div
className={`grid min-w-[920px] grid-cols-[260px_86px_132px_220px_164px] gap-3 items-center border-b border-base-content/5 border-l-2 px-3 py-2 text-[11px] last:border-b-0 ${ className={`grid min-w-[920px] grid-cols-[260px_86px_132px_220px_164px] gap-3 items-center border-b border-base-content/5 border-l-2 px-3 py-2 text-xs last:border-b-0 ${
isOwner isOwner
? "border-l-primary bg-primary/[0.05]" ? "border-l-primary bg-primary/[0.05]"
: "border-l-transparent hover:bg-base-content/[0.02]" : "border-l-transparent hover:bg-base-content/[0.02]"
@@ -582,7 +582,7 @@ function ParticipantRow({
/> />
) : null} ) : null}
{participant.championLevel > 0 && ( {participant.championLevel > 0 && (
<span className="absolute bottom-0 right-0 min-w-4 bg-base-300 px-1 text-center text-[9px] font-black leading-4 text-base-content"> <span className="absolute bottom-0 right-0 min-w-4 bg-base-300 px-1 text-center text-xs font-black leading-4 text-base-content">
{participant.championLevel} {participant.championLevel}
</span> </span>
)} )}
@@ -616,7 +616,7 @@ function ParticipantRow({
> >
{participantName} {participantName}
</div> </div>
<div className="truncate text-[10px] text-base-content/35"> <div className="truncate text-xs text-base-content/35">
{participant.tagLine ? `#${participant.tagLine} · ` : ""} {participant.tagLine ? `#${participant.tagLine} · ` : ""}
{(LANE_LABELS[participant.teamPosition] ?? participant.teamPosition) || {(LANE_LABELS[participant.teamPosition] ?? participant.teamPosition) ||
"포지션 없음"} "포지션 없음"}
@@ -632,13 +632,13 @@ function ParticipantRow({
<span className="text-base-content/25"> / </span> <span className="text-base-content/25"> / </span>
{participant.assists} {participant.assists}
</div> </div>
<div className={`mt-0.5 text-[10px] font-bold ${kdaClass(kda)}`}> <div className={`mt-0.5 text-xs font-bold ${kdaClass(kda)}`}>
{participant.deaths === 0 ? "Perfect" : `${kda} KDA`} {participant.deaths === 0 ? "Perfect" : `${kda} KDA`}
</div> </div>
</div> </div>
<div className="space-y-2 tabular-nums"> <div className="space-y-2 tabular-nums">
<div className="flex items-center justify-between gap-2 text-[10px] text-base-content/45"> <div className="flex items-center justify-between gap-2 text-xs text-base-content/45">
<span>CS</span> <span>CS</span>
<span className="font-bold text-base-content/70"> <span className="font-bold text-base-content/70">
{participant.totalCs} ({participant.csPerMin}/m) {participant.totalCs} ({participant.csPerMin}/m)
@@ -667,7 +667,7 @@ function ParticipantRow({
fillClass="bg-base-content/35" fillClass="bg-base-content/35"
/> />
</div> </div>
<div className="text-[10px] text-base-content/40"> <div className="text-xs text-base-content/40">
시야 {participant.visionScore} · 와드 {participant.wardsPlaced}/ 시야 {participant.visionScore} · 와드 {participant.wardsPlaced}/
{participant.wardsKilled} · 제어 {participant.controlWardsBought} {participant.wardsKilled} · 제어 {participant.controlWardsBought}
</div> </div>
@@ -706,7 +706,7 @@ function MatchDetailPanel({
if (participants.length === 0) { if (participants.length === 0) {
return ( return (
<div className="p-4 text-center text-[12px] text-base-content/35"> <div className="p-4 text-center text-xs text-base-content/35">
이 경기의 상세 팀 데이터가 아직 없습니다. 이 경기의 상세 팀 데이터가 아직 없습니다.
</div> </div>
); );
@@ -721,7 +721,7 @@ function MatchDetailPanel({
> >
<TeamHeader team={team} /> <TeamHeader team={team} />
<div className="overflow-x-auto"> <div className="overflow-x-auto">
<div className="grid min-w-[920px] grid-cols-[260px_86px_132px_220px_164px] gap-3 border-b border-base-content/10 bg-base-200/40 px-3 py-2 text-[10px] font-black uppercase tracking-wider text-base-content/35"> <div className="grid min-w-[920px] grid-cols-[260px_86px_132px_220px_164px] gap-3 border-b border-base-content/10 bg-base-200/40 px-3 py-2 text-xs font-black uppercase tracking-wider text-base-content/35">
<div>소환사</div> <div>소환사</div>
<div className="text-center">KDA</div> <div className="text-center">KDA</div>
<div>CS · 골드</div> <div>CS · 골드</div>
@@ -766,16 +766,16 @@ function RecentMatchCard({
> >
<div className="p-4 grid lg:grid-cols-[120px_1fr_120px_1.5fr_40px] gap-4 items-center"> <div className="p-4 grid lg:grid-cols-[120px_1fr_120px_1.5fr_40px] gap-4 items-center">
<div className="text-center lg:text-left"> <div className="text-center lg:text-left">
<div className={`text-[12px] font-black ${resultClass}`}> <div className={`text-xs font-black ${resultClass}`}>
{match.remake ? "다시하기" : match.win ? "승리" : "패배"} {match.remake ? "다시하기" : match.win ? "승리" : "패배"}
</div> </div>
<div className="text-[11px] text-base-content/35 mt-1"> <div className="text-xs text-base-content/35 mt-1">
{match.queueLabel} {match.queueLabel}
</div> </div>
<div className="text-[11px] text-base-content/25"> <div className="text-xs text-base-content/25">
{formatDate(match.gameCreation)} {formatDate(match.gameCreation)}
</div> </div>
<div className="text-[11px] text-base-content/25"> <div className="text-xs text-base-content/25">
{formatDuration(match.gameDuration)} {formatDuration(match.gameDuration)}
</div> </div>
</div> </div>
@@ -790,7 +790,7 @@ function RecentMatchCard({
<div className="font-bold text-base-content truncate"> <div className="font-bold text-base-content truncate">
{championName} {championName}
</div> </div>
<div className="text-[11px] text-base-content/35"> <div className="text-xs text-base-content/35">
Lv.{match.championLevel} ·{" "} Lv.{match.championLevel} ·{" "}
{(LANE_LABELS[match.teamPosition] ?? match.teamPosition) || {(LANE_LABELS[match.teamPosition] ?? match.teamPosition) ||
"포지션 없음"} "포지션 없음"}
@@ -814,17 +814,17 @@ function RecentMatchCard({
<span>{match.assists}</span> <span>{match.assists}</span>
</div> </div>
<div <div
className={`text-[12px] font-bold tabular-nums ${kdaClass(match.kda)}`} className={`text-xs font-bold tabular-nums ${kdaClass(match.kda)}`}
> >
{match.deaths === 0 ? "Perfect" : `${match.kda} 평점`} {match.deaths === 0 ? "Perfect" : `${match.kda} 평점`}
</div> </div>
<div className="mt-1 text-[11px] text-base-content/35"> <div className="mt-1 text-xs text-base-content/35">
킬 관여 {match.killParticipation}% 킬 관여 {match.killParticipation}%
</div> </div>
</div> </div>
<div className="grid sm:grid-cols-[100px_1fr] gap-4 items-center"> <div className="grid sm:grid-cols-[100px_1fr] gap-4 items-center">
<div className="space-y-1 text-[11px] text-base-content/45"> <div className="space-y-1 text-xs text-base-content/45">
<div> <div>
CS{" "} CS{" "}
<span className="font-bold text-base-content/70"> <span className="font-bold text-base-content/70">
@@ -865,7 +865,7 @@ function RecentMatchCard({
aria-expanded={expanded} aria-expanded={expanded}
aria-label={expanded ? "상세 전적 접기" : "상세 전적 펼치기"} aria-label={expanded ? "상세 전적 접기" : "상세 전적 펼치기"}
> >
<span className="text-[11px] font-bold lg:hidden"> <span className="text-xs font-bold lg:hidden">
{expanded ? "상세 접기" : "상세 보기"} {expanded ? "상세 접기" : "상세 보기"}
</span> </span>
{expanded ? ( {expanded ? (
@@ -1156,7 +1156,7 @@ export default function UserHistoryPage() {
<span>최근 저장: {formatLastFetched(profile.lastFetchedAt)}</span> <span>최근 저장: {formatLastFetched(profile.lastFetchedAt)}</span>
</div> </div>
</div> </div>
<div className="border border-dashed border-base-content/10 px-3 py-2 text-[11px] text-base-content/35 sm:text-right space-y-2"> <div className="border border-dashed border-base-content/10 px-3 py-2 text-xs text-base-content/35 sm:text-right space-y-2">
<div> <div>
{isInternalQueue ? ( {isInternalQueue ? (
<> <>
@@ -1186,7 +1186,7 @@ export default function UserHistoryPage() {
: "정보 갱신"} : "정보 갱신"}
</button> </button>
{!isInternalQueue && ( {!isInternalQueue && (
<div className="text-[10px] text-base-content/25"> <div className="text-xs text-base-content/25">
갱신 소켓: {refreshSocket.connectionStatus} 갱신 소켓: {refreshSocket.connectionStatus}
</div> </div>
)} )}
@@ -1239,14 +1239,14 @@ export default function UserHistoryPage() {
))} ))}
</div> </div>
) : ( ) : (
<div className="px-3 py-2 text-[11px] text-base-content/40"> <div className="px-3 py-2 text-xs text-base-content/40">
내전 탭은 토너먼트 코드 결과 수집 데이터를 기준으로 집계합니다. 내전 탭은 토너먼트 코드 결과 수집 데이터를 기준으로 집계합니다.
</div> </div>
)} )}
{selectedChampionName && ( {selectedChampionName && (
<button <button
type="button" type="button"
className="text-[11px] px-2.5 py-1 border border-primary/30 text-primary bg-primary/5" className="text-xs px-2.5 py-1 border border-primary/30 text-primary bg-primary/5"
onClick={() => updateSearch({ championId: null })} onClick={() => updateSearch({ championId: null })}
> >
{selectedChampionName} 필터 해제 {selectedChampionName} 필터 해제
@@ -1304,7 +1304,7 @@ export default function UserHistoryPage() {
sub="가장 최근 경기 기준" sub="가장 최근 경기 기준"
/> />
<div className="border border-base-content/8 bg-base-100 p-4"> <div className="border border-base-content/8 bg-base-100 p-4">
<div className="text-[10px] font-bold uppercase tracking-wider text-base-content/30"> <div className="text-xs font-bold uppercase tracking-wider text-base-content/30">
자주 플레이한 챔피언 자주 플레이한 챔피언
</div> </div>
<div className="mt-3 flex items-center gap-3"> <div className="mt-3 flex items-center gap-3">
@@ -1321,13 +1321,13 @@ export default function UserHistoryPage() {
championId={champion.championId} championId={champion.championId}
manifest={ddragon} manifest={ddragon}
/> />
<div className="mt-1 text-[10px] text-base-content/40 group-hover:text-primary"> <div className="mt-1 text-xs text-base-content/40 group-hover:text-primary">
{champion.winRate}% {champion.winRate}%
</div> </div>
</button> </button>
))} ))}
{(summary?.topChampions ?? []).length === 0 && ( {(summary?.topChampions ?? []).length === 0 && (
<span className="text-[11px] text-base-content/25"> <span className="text-xs text-base-content/25">
기록 없음 기록 없음
</span> </span>
)} )}
@@ -1340,7 +1340,7 @@ export default function UserHistoryPage() {
<div className="flex flex-col sm:flex-row sm:items-end sm:justify-between gap-3 mb-3"> <div className="flex flex-col sm:flex-row sm:items-end sm:justify-between gap-3 mb-3">
<div> <div>
<h2 className="text-sm font-bold text-base-content">챔피언 통계</h2> <h2 className="text-sm font-bold text-base-content">챔피언 통계</h2>
<p className="mt-1 text-[11px] text-base-content/35"> <p className="mt-1 text-xs text-base-content/35">
저장된 데이터를 기준으로 집계합니다. 최신 데이터가 반영되지 않을 저장된 데이터를 기준으로 집계합니다. 최신 데이터가 반영되지 않을
수 있습니다. 수 있습니다.
</p> </p>
@@ -1380,7 +1380,7 @@ export default function UserHistoryPage() {
<section> <section>
<div className="flex items-center justify-between gap-3 mb-3"> <div className="flex items-center justify-between gap-3 mb-3">
<h2 className="text-sm font-bold text-base-content">매치 히스토리</h2> <h2 className="text-sm font-bold text-base-content">매치 히스토리</h2>
<span className="text-[11px] text-base-content/35"> <span className="text-xs text-base-content/35">
최근 저장: {formatLastFetched(historyLastFetchedAt)} 최근 저장: {formatLastFetched(historyLastFetchedAt)}
</span> </span>
</div> </div>
@@ -61,7 +61,7 @@ function JobCard({
<div className="border border-base-content/10 bg-base-100 p-4"> <div className="border border-base-content/10 bg-base-100 p-4">
<div className="flex flex-col sm:flex-row sm:items-start sm:justify-between gap-3"> <div className="flex flex-col sm:flex-row sm:items-start sm:justify-between gap-3">
<div> <div>
<div className="text-[11px] font-mono text-base-content/35"> <div className="text-xs font-mono text-base-content/35">
{job.jobId} {job.jobId}
</div> </div>
<div className="mt-1 flex flex-wrap items-center gap-2"> <div className="mt-1 flex flex-wrap items-center gap-2">
@@ -92,7 +92,7 @@ function JobCard({
style={{ width: `${progress(job)}%` }} style={{ width: `${progress(job)}%` }}
/> />
</div> </div>
<div className="mt-2 flex flex-wrap justify-between gap-2 text-[11px] text-base-content/35"> <div className="mt-2 flex flex-wrap justify-between gap-2 text-xs text-base-content/35">
<span> <span>
{formatDate(job.windowStart)} ~ {formatDate(job.windowEnd)} {formatDate(job.windowStart)} ~ {formatDate(job.windowEnd)}
</span> </span>
@@ -306,7 +306,7 @@ export default function LegacyImportPage() {
<section className="border border-base-content/10 bg-base-100 overflow-hidden mb-6"> <section className="border border-base-content/10 bg-base-100 overflow-hidden mb-6">
<div className="px-4 py-3 border-b border-base-content/10"> <div className="px-4 py-3 border-b border-base-content/10">
<h2 className="text-sm font-bold">멤버별 윈도우</h2> <h2 className="text-sm font-bold">멤버별 윈도우</h2>
<p className="mt-1 text-[11px] text-base-content/35"> <p className="mt-1 text-xs text-base-content/35">
기본 시작일은 2024-05-01이며, 필요하면 멤버별 시작/종료 시간을 조정할 수 있습니다. 기본 시작일은 2024-05-01이며, 필요하면 멤버별 시작/종료 시간을 조정할 수 있습니다.
비활성 멤버는 종료일이 마지막 업데이트 시각으로 잡힙니다. 비활성 멤버는 종료일이 마지막 업데이트 시각으로 잡힙니다.
</p> </p>
@@ -314,7 +314,7 @@ export default function LegacyImportPage() {
<div className="overflow-x-auto"> <div className="overflow-x-auto">
<table className="w-full min-w-[900px] text-left"> <table className="w-full min-w-[900px] text-left">
<thead> <thead>
<tr className="bg-base-200/40 border-b border-base-content/10 text-[11px] uppercase tracking-wider text-base-content/35"> <tr className="bg-base-200/40 border-b border-base-content/10 text-xs uppercase tracking-wider text-base-content/35">
<th className="px-3 py-2">멤버</th> <th className="px-3 py-2">멤버</th>
<th className="px-3 py-2">Riot ID</th> <th className="px-3 py-2">Riot ID</th>
<th className="px-3 py-2">상태</th> <th className="px-3 py-2">상태</th>
@@ -161,7 +161,7 @@ export default function LegacyMatchesPage() {
<div className="overflow-x-auto"> <div className="overflow-x-auto">
<table className="w-full min-w-[900px] text-left"> <table className="w-full min-w-[900px] text-left">
<thead> <thead>
<tr className="bg-base-200/40 border-b border-base-content/10 text-[11px] uppercase tracking-wider text-base-content/35"> <tr className="bg-base-200/40 border-b border-base-content/10 text-xs uppercase tracking-wider text-base-content/35">
<th className="px-3 py-2 w-8"> <th className="px-3 py-2 w-8">
<input <input
type="checkbox" type="checkbox"
@@ -218,7 +218,7 @@ export default function LegacyMatchesPage() {
<td className="px-3 py-2 text-right"> <td className="px-3 py-2 text-right">
<button <button
type="button" type="button"
className="text-[11px] px-2 py-1 border border-red-500/20 text-red-400 hover:bg-red-500/10" className="text-xs px-2 py-1 border border-red-500/20 text-red-400 hover:bg-red-500/10"
disabled={deleteMutation.isPending} disabled={deleteMutation.isPending}
onClick={() => { onClick={() => {
if (!window.confirm('이 매치를 삭제할까요?')) return; if (!window.confirm('이 매치를 삭제할까요?')) return;
+7 -7
View File
@@ -37,7 +37,7 @@ const GAME_MODE_LABEL: Record<MatchGameMode, string> = {
function RequiredBadge() { function RequiredBadge() {
return ( return (
<span className="ml-1 inline-flex items-center border border-primary/20 bg-primary/5 px-1.5 py-0.5 text-[10px] font-bold text-primary"> <span className="ml-1 inline-flex items-center border border-primary/20 bg-primary/5 px-1.5 py-0.5 text-xs font-bold text-primary">
필수 필수
</span> </span>
); );
@@ -267,7 +267,7 @@ export default function MatchAdminPage() {
</label> </label>
<label className="text-xs text-base-content/45 md:col-span-2"> <label className="text-xs text-base-content/45 md:col-span-2">
설명 설명
<span className="ml-1 text-[10px] text-base-content/25">선택</span> <span className="ml-1 text-xs text-base-content/25">선택</span>
<textarea <textarea
value={form.description} value={form.description}
onChange={(event) => setForm((current) => ({ ...current, description: event.target.value }))} onChange={(event) => setForm((current) => ({ ...current, description: event.target.value }))}
@@ -319,7 +319,7 @@ export default function MatchAdminPage() {
<option key={value} value={value}>{label}</option> <option key={value} value={value}>{label}</option>
))} ))}
</select> </select>
<span className="mt-1 block text-[10px] text-amber-500/80"> <span className="mt-1 block text-xs text-amber-500/80">
현재 경매/코드 연결은 페어 방식 기준으로 동작합니다. 현재 경매/코드 연결은 페어 방식 기준으로 동작합니다.
</span> </span>
</label> </label>
@@ -377,7 +377,7 @@ export default function MatchAdminPage() {
<div className="overflow-x-auto"> <div className="overflow-x-auto">
<table className="w-full min-w-[900px] text-left"> <table className="w-full min-w-[900px] text-left">
<thead> <thead>
<tr className="bg-base-200/40 border-b border-base-content/10 text-[11px] uppercase tracking-wider text-base-content/35"> <tr className="bg-base-200/40 border-b border-base-content/10 text-xs uppercase tracking-wider text-base-content/35">
<th className="px-3 py-2">시간</th> <th className="px-3 py-2">시간</th>
<th className="px-3 py-2">내전</th> <th className="px-3 py-2">내전</th>
<th className="px-3 py-2">상태</th> <th className="px-3 py-2">상태</th>
@@ -396,7 +396,7 @@ export default function MatchAdminPage() {
<Link to={`/match/${match._id}`} className="text-sm font-bold hover:text-primary"> <Link to={`/match/${match._id}`} className="text-sm font-bold hover:text-primary">
{match.title} {match.title}
</Link> </Link>
<div className="mt-0.5 text-[11px] text-base-content/30"> <div className="mt-0.5 text-xs text-base-content/30">
{match.description || '-'} {match.description || '-'}
</div> </div>
</td> </td>
@@ -411,14 +411,14 @@ export default function MatchAdminPage() {
<div className="inline-flex gap-2"> <div className="inline-flex gap-2">
<button <button
type="button" type="button"
className="text-[11px] px-2 py-1 border border-base-content/10 text-base-content/50 hover:text-primary" className="text-xs px-2 py-1 border border-base-content/10 text-base-content/50 hover:text-primary"
onClick={() => openEdit(match)} onClick={() => openEdit(match)}
> >
수정 수정
</button> </button>
<button <button
type="button" type="button"
className="text-[11px] px-2 py-1 border border-red-500/20 text-red-400 hover:bg-red-500/10" className="text-xs px-2 py-1 border border-red-500/20 text-red-400 hover:bg-red-500/10"
disabled={deleteMutation.isPending} disabled={deleteMutation.isPending}
onClick={() => { onClick={() => {
if (!window.confirm('이 내전을 삭제할까요?')) return; if (!window.confirm('이 내전을 삭제할까요?')) return;
@@ -200,7 +200,7 @@ export default function TournamentCodesPage() {
<section className="grid sm:grid-cols-5 gap-3 mb-6"> <section className="grid sm:grid-cols-5 gap-3 mb-6">
{STATES.map((state) => ( {STATES.map((state) => (
<div key={state} className="border border-base-content/10 bg-base-100 p-4"> <div key={state} className="border border-base-content/10 bg-base-100 p-4">
<div className="text-[10px] uppercase tracking-wider text-base-content/30"> <div className="text-xs uppercase tracking-wider text-base-content/30">
{state} {state}
</div> </div>
<div className="mt-2 text-2xl font-black tabular-nums"> <div className="mt-2 text-2xl font-black tabular-nums">
@@ -273,7 +273,7 @@ export default function TournamentCodesPage() {
<div className="overflow-x-auto"> <div className="overflow-x-auto">
<table className="w-full min-w-[900px] text-left"> <table className="w-full min-w-[900px] text-left">
<thead> <thead>
<tr className="bg-base-200/40 border-b border-base-content/10 text-[11px] uppercase tracking-wider text-base-content/35"> <tr className="bg-base-200/40 border-b border-base-content/10 text-xs uppercase tracking-wider text-base-content/35">
<th className="px-3 py-2">코드</th> <th className="px-3 py-2">코드</th>
<th className="px-3 py-2">상태</th> <th className="px-3 py-2">상태</th>
<th className="px-3 py-2">만료</th> <th className="px-3 py-2">만료</th>
@@ -309,7 +309,7 @@ export default function TournamentCodesPage() {
{(code.state === 'released' || code.state === 'reserved') && ( {(code.state === 'released' || code.state === 'reserved') && (
<button <button
type="button" type="button"
className="text-[11px] px-2 py-1 border border-base-content/10 text-base-content/50 hover:text-primary" className="text-xs px-2 py-1 border border-base-content/10 text-base-content/50 hover:text-primary"
onClick={() => onClick={() =>
restoreMutation.mutate(code._id, { restoreMutation.mutate(code._id, {
onSuccess: invalidate, onSuccess: invalidate,
@@ -322,7 +322,7 @@ export default function TournamentCodesPage() {
{code.state === 'available' && ( {code.state === 'available' && (
<button <button
type="button" type="button"
className="text-[11px] px-2 py-1 border border-red-500/20 text-red-400" className="text-xs px-2 py-1 border border-red-500/20 text-red-400"
onClick={() => onClick={() =>
deleteMutation.mutate(code._id, { deleteMutation.mutate(code._id, {
onSuccess: invalidate, onSuccess: invalidate,
Binary file not shown.

After

Width:  |  Height:  |  Size: 176 KiB

Binary file not shown.
Binary file not shown.

Before

Width:  |  Height:  |  Size: 54 KiB

After

Width:  |  Height:  |  Size: 198 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 88 KiB

After

Width:  |  Height:  |  Size: 106 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 188 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 115 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 137 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 54 KiB

After

Width:  |  Height:  |  Size: 92 KiB

+1 -1
View File
@@ -20,7 +20,7 @@
}, },
"keywords": [], "keywords": [],
"author": "", "author": "",
"license": "ISC", "license": "LGPL-2.0",
"packageManager": "pnpm@10.4.1", "packageManager": "pnpm@10.4.1",
"dependencies": { "dependencies": {
"@infisical/sdk": "^5.0.0" "@infisical/sdk": "^5.0.0"