@@ -397,13 +398,13 @@ function ScrimsDaySeparatedBookedCards({ posts }: { posts: ScrimPost[] }) {
const { formatDate } = useTimeFormat();
const postsByDay = R.groupBy(posts, (post) =>
- databaseTimestampToDate(post.at).getDate(),
+ format(databaseTimestampToDate(post.at), "yyyy-MM-dd"),
);
return (
{Object.entries(postsByDay)
- .sort((a, b) => a[1][0].at - b[1][0].at)
+ .sort(([a], [b]) => a.localeCompare(b))
.map(([day, posts]) => {
return (
diff --git a/app/features/sendouq-match/SQMatchRepository.server.ts b/app/features/sendouq-match/SQMatchRepository.server.ts
index bc386617e..8a5aa5d22 100644
--- a/app/features/sendouq-match/SQMatchRepository.server.ts
+++ b/app/features/sendouq-match/SQMatchRepository.server.ts
@@ -16,8 +16,10 @@ import {
concatUserSubmittedImagePrefix,
tournamentLogoWithDefault,
} from "~/utils/kysely.server";
+import { errorIsSqliteUniqueConstraintFailure } from "~/utils/sql";
import type { Unpacked } from "~/utils/types";
import { FULL_GROUP_SIZE } from "../sendouq/q-constants";
+import { SendouQError } from "../sendouq/q-utils.server";
import * as SQGroupRepository from "../sendouq/SQGroupRepository.server";
import { MATCHES_PER_SEASONS_PAGE } from "../user-page/user-page-constants";
import { compareMatchToReportedScores } from "./core/match.server";
@@ -410,7 +412,15 @@ export function create({
memento: JSON.stringify(memento),
})
.returningAll()
- .executeTakeFirstOrThrow();
+ .executeTakeFirstOrThrow()
+ .catch((error) => {
+ // race: another manager matched one of the two groups first, tripping the
+ // unique constraint on GroupMatch.alphaGroupId / bravoGroupId
+ if (errorIsSqliteUniqueConstraintFailure(error)) {
+ throw new SendouQError("Group is already in a match");
+ }
+ throw error;
+ });
await trx
.insertInto("GroupMatchMap")
diff --git a/app/features/sendouq-match/core/skills.server.ts b/app/features/sendouq-match/core/skills.server.ts
index c0672ede5..42c136480 100644
--- a/app/features/sendouq-match/core/skills.server.ts
+++ b/app/features/sendouq-match/core/skills.server.ts
@@ -1,5 +1,4 @@
-import type { Rating } from "node_modules/openskill/dist/types";
-import { ordinal } from "openskill";
+import { ordinal, type Rating } from "openskill";
import type {
GroupSkillDifference,
Tables,
diff --git a/app/features/sendouq/core/SendouQ.server.test.ts b/app/features/sendouq/core/SendouQ.server.test.ts
index 1ceb5a359..76e27b2fc 100644
--- a/app/features/sendouq/core/SendouQ.server.test.ts
+++ b/app/features/sendouq/core/SendouQ.server.test.ts
@@ -2,6 +2,7 @@ import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
import { db } from "~/db/sql";
import { refreshUserSkills } from "~/features/mmr/tiered.server";
import * as PrivateUserNoteRepository from "~/features/sendouq/PrivateUserNoteRepository.server";
+import { databaseTimestampNow } from "~/utils/dates";
import { dbInsertUsers, dbReset } from "~/utils/Test";
import * as SQGroupRepository from "../SQGroupRepository.server";
import { refreshSendouQInstance, SendouQ } from "./SendouQ.server";
@@ -393,9 +394,18 @@ describe("SendouQ", () => {
await insertSkill(3, 2000);
await insertSkill(4, 1050);
- await createGroup([4]);
- await createGroup([2]);
- await createGroup([3]);
+ const g4Id = await createGroup([4]);
+ const g2Id = await createGroup([2]);
+ const g3Id = await createGroup([3]);
+ // Force identical latestActionAt so the sort comparator's
+ // recency tie-breaker stays neutral and the assertion does
+ // not depend on whether the group inserts straddle a
+ // millisecond boundary (which they can on slow CI).
+ await db
+ .updateTable("Group")
+ .set({ latestActionAt: databaseTimestampNow() })
+ .where("id", "in", [g4Id, g2Id, g3Id])
+ .execute();
await refreshSendouQInstance();
const notes = await PrivateUserNoteRepository.byAuthorUserId(1);
diff --git a/app/features/sidebar/core/StreamRanking.ts b/app/features/sidebar/core/StreamRanking.ts
index 10c53c358..270bc079d 100644
--- a/app/features/sidebar/core/StreamRanking.ts
+++ b/app/features/sidebar/core/StreamRanking.ts
@@ -25,14 +25,28 @@ export function rank(
return [...live, ...upcoming].map((rs) => rs.stream);
}
+const SMALL_TOURNAMENT_PENALTY = 4;
+
export function tournamentTierToScore(
tier: TournamentTierNumber | null,
+ membersPerTeam?: number,
): number {
- return tier ?? 9;
+ const base = tier ?? 9;
+ const isSmallTeamSize = (membersPerTeam ?? 4) < 4;
+
+ return Math.min(9, base + (isSmallTeamSize ? SMALL_TOURNAMENT_PENALTY : 0));
}
-export function upcomingTournamentTierToScore(tier: number): number {
- return Math.min(9, tier + 4);
+export function upcomingTournamentTierToScore(
+ tier: number,
+ membersPerTeam?: number,
+): number {
+ const isSmallTeamSize = (membersPerTeam ?? 4) < 4;
+
+ return Math.min(
+ 9,
+ tier + 4 + (isSmallTeamSize ? SMALL_TOURNAMENT_PENALTY : 0),
+ );
}
export function sendouQTierToScore(tier: {
diff --git a/app/features/sidebar/core/sidebar.server.ts b/app/features/sidebar/core/sidebar.server.ts
index 7f1de2cfc..bd37a3fdd 100644
--- a/app/features/sidebar/core/sidebar.server.ts
+++ b/app/features/sidebar/core/sidebar.server.ts
@@ -152,7 +152,10 @@ async function combinedStreams(): Promise
{
for (const stream of tournamentStreams) {
ranked.push({
stream,
- score: StreamRanking.tournamentTierToScore(stream.tier),
+ score: StreamRanking.tournamentTierToScore(
+ stream.tier,
+ stream.membersPerTeam,
+ ),
});
}
@@ -215,7 +218,8 @@ async function combinedStreams(): Promise {
if (event.startTime < nowTimestamp) continue;
if (event.startTime > threeDaysFromNow) continue;
if (event.hidden) continue;
- if ((event.minMembersPerTeam ?? 4) < 4) continue;
+
+ const membersPerTeam = event.minMembersPerTeam ?? 4;
ranked.push({
stream: {
@@ -226,9 +230,13 @@ async function combinedStreams(): Promise {
subtitle: "",
startsAt: event.startTime,
tier: (event.tier as TournamentTierNumber) ?? null,
+ membersPerTeam,
tentativeTier: event.tentativeTier ?? undefined,
},
- score: StreamRanking.upcomingTournamentTierToScore(effectiveTier),
+ score: StreamRanking.upcomingTournamentTierToScore(
+ effectiveTier,
+ membersPerTeam,
+ ),
});
}
diff --git a/app/features/team/TeamRepository.server.ts b/app/features/team/TeamRepository.server.ts
index f7af186b5..da4af4054 100644
--- a/app/features/team/TeamRepository.server.ts
+++ b/app/features/team/TeamRepository.server.ts
@@ -192,6 +192,7 @@ export async function findResultsById(teamId: number) {
"CalendarEventDate.eventId",
"CalendarEvent.id",
)
+ .innerJoin("Tournament", "Tournament.id", "results.tournamentId")
.select((eb) => [
"results.placement",
"results.tournamentId",
@@ -199,6 +200,7 @@ export async function findResultsById(teamId: number) {
"results.tournamentTeamId",
"CalendarEvent.name as tournamentName",
"CalendarEventDate.startTime",
+ "Tournament.tier",
tournamentLogoOrNull(eb).as("logoUrl"),
jsonArrayFrom(
eb
@@ -311,10 +313,7 @@ export async function update({
bio,
bsky,
tag,
- customTheme,
-}: Pick, "id" | "name" | "bio" | "bsky" | "tag"> & {
- customTheme: CustomTheme | null;
-}) {
+}: Pick, "id" | "name" | "bio" | "bsky" | "tag">) {
const customUrl = mySlugify(name);
const team = await db
@@ -325,7 +324,6 @@ export async function update({
bio,
bsky,
tag,
- customTheme: customTheme ? JSON.stringify(customTheme) : null,
})
.where("id", "=", id)
.returningAll()
diff --git a/app/features/team/actions/t.$customUrl.edit.server.test.ts b/app/features/team/actions/t.$customUrl.edit.server.test.ts
index 6e1888b2f..3cb64917f 100644
--- a/app/features/team/actions/t.$customUrl.edit.server.test.ts
+++ b/app/features/team/actions/t.$customUrl.edit.server.test.ts
@@ -1,4 +1,8 @@
import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { REGULAR_USER_TEST_ID } from "~/db/seed/constants";
+import { db } from "~/db/sql";
+import * as TeamRepository from "~/features/team/TeamRepository.server";
+import { clampThemeToGamut } from "~/utils/oklch-gamut";
import {
assertResponseErrored,
dbInsertUsers,
@@ -20,7 +24,7 @@ const editTeamProfileAction = wrappedAction({
isJsonSubmission: true,
});
-const DEFAULT_FIELDS = {
+const DEFAULT_EDIT_FIELDS = {
_action: "EDIT",
name: "Team 1",
bio: "",
@@ -28,6 +32,31 @@ const DEFAULT_FIELDS = {
tag: "",
} as const;
+const VALID_CUSTOM_THEME = {
+ baseHue: 180,
+ baseChroma: 0.05,
+ accentHue: 200,
+ accentChroma: 0.1,
+ chatHue: null,
+ radiusBox: 3,
+ radiusField: 2,
+ radiusSelector: 2,
+ borderWidth: 2,
+ sizeField: 1,
+ sizeSelector: 1,
+ sizeSpacing: 1,
+} as const;
+
+const expectedStoredTheme = () =>
+ JSON.parse(JSON.stringify(clampThemeToGamut(VALID_CUSTOM_THEME)));
+
+const makeUserPatron = () =>
+ db
+ .updateTable("User")
+ .set({ patronTier: 2 })
+ .where("id", "=", REGULAR_USER_TEST_ID)
+ .execute();
+
describe("team page editing", () => {
beforeEach(async () => {
await dbInsertUsers();
@@ -37,65 +66,85 @@ describe("team page editing", () => {
dbReset();
});
- it("adds valid custom theme", async () => {
+ it("sets a custom theme via UPDATE_CUSTOM_THEME", async () => {
+ await makeUserPatron();
+
const response = await editTeamProfileAction(
{
- customTheme: {
- baseHue: 180,
- baseChroma: 0.05,
- accentHue: 200,
- accentChroma: 0.1,
- chatHue: null,
- radiusBox: 3,
- radiusField: 2,
- radiusSelector: 2,
- borderWidth: 2,
- sizeField: 1,
- sizeSelector: 1,
- sizeSpacing: 1,
- },
- ...DEFAULT_FIELDS,
+ _action: "UPDATE_CUSTOM_THEME",
+ newValue: VALID_CUSTOM_THEME,
},
{ user: "regular", params: { customUrl: "team-1" } },
);
- expect(response.status).toBe(302);
+ expect(response).toEqual({ ok: true });
+
+ const team = await TeamRepository.findByCustomUrl("team-1");
+ expect(team?.customTheme).toEqual(expectedStoredTheme());
});
- it("allows null custom theme", async () => {
- const response = await editTeamProfileAction(
+ it("clears a custom theme via UPDATE_CUSTOM_THEME with null", async () => {
+ await makeUserPatron();
+
+ await editTeamProfileAction(
{
- customTheme: null,
- ...DEFAULT_FIELDS,
+ _action: "UPDATE_CUSTOM_THEME",
+ newValue: VALID_CUSTOM_THEME,
},
{ user: "regular", params: { customUrl: "team-1" } },
);
- expect(response.status).toBe(302);
- });
-
- it("prevents adding custom theme with invalid values", async () => {
const response = await editTeamProfileAction(
{
- customTheme: {
+ _action: "UPDATE_CUSTOM_THEME",
+ newValue: null,
+ },
+ { user: "regular", params: { customUrl: "team-1" } },
+ );
+
+ expect(response).toEqual({ ok: true });
+
+ const team = await TeamRepository.findByCustomUrl("team-1");
+ expect(team?.customTheme).toBeNull();
+ });
+
+ it("prevents setting an invalid custom theme", async () => {
+ await makeUserPatron();
+
+ const response = await editTeamProfileAction(
+ {
+ _action: "UPDATE_CUSTOM_THEME",
+ newValue: {
+ ...VALID_CUSTOM_THEME,
baseHue: 500, // Invalid: max is 360
- baseChroma: 0.05,
- accentHue: 200,
- accentChroma: 0.1,
- chatHue: null,
- radiusBox: 3,
- radiusField: 2,
- radiusSelector: 2,
- borderWidth: 2,
- sizeField: 1,
- sizeSelector: 1,
- sizeSpacing: 1,
},
- ...DEFAULT_FIELDS,
},
{ user: "regular", params: { customUrl: "team-1" } },
);
assertResponseErrored(response);
});
+
+ it("preserves an existing custom theme when editing the team profile", async () => {
+ await makeUserPatron();
+
+ await editTeamProfileAction(
+ {
+ _action: "UPDATE_CUSTOM_THEME",
+ newValue: VALID_CUSTOM_THEME,
+ },
+ { user: "regular", params: { customUrl: "team-1" } },
+ );
+
+ const response = await editTeamProfileAction(
+ { ...DEFAULT_EDIT_FIELDS, bio: "Updated bio" },
+ { user: "regular", params: { customUrl: "team-1" } },
+ );
+
+ expect(response.status).toBe(302);
+
+ const team = await TeamRepository.findByCustomUrl("team-1");
+ expect(team?.customTheme).toEqual(expectedStoredTheme());
+ expect(team?.bio).toBe("Updated bio");
+ });
});
diff --git a/app/features/team/actions/t.$customUrl.edit.server.ts b/app/features/team/actions/t.$customUrl.edit.server.ts
index 44cb20e87..f05856b49 100644
--- a/app/features/team/actions/t.$customUrl.edit.server.ts
+++ b/app/features/team/actions/t.$customUrl.edit.server.ts
@@ -87,15 +87,9 @@ export const action: ActionFunction = async ({ request, params }) => {
return { errors: ["forms:errors.duplicateName"] };
}
- const customTheme =
- canAddCustomizedColors(team) && data.customTheme
- ? clampThemeToGamut(data.customTheme)
- : null;
-
const updatedTeam = await TeamRepository.update({
id: team.id,
...data,
- customTheme,
});
throw redirect(teamPage(updatedTeam.customUrl));
diff --git a/app/features/team/components/TeamResultsTable.tsx b/app/features/team/components/TeamResultsTable.tsx
index 67135c690..70a506b0b 100644
--- a/app/features/team/components/TeamResultsTable.tsx
+++ b/app/features/team/components/TeamResultsTable.tsx
@@ -6,6 +6,7 @@ import { SendouButton } from "~/components/elements/Button";
import { SendouPopover } from "~/components/elements/Popover";
import { Placement } from "~/components/Placement";
import { Table } from "~/components/Table";
+import { TierPill } from "~/components/TierPill";
import type { TeamResultsLoaderData } from "~/features/team/loaders/t.$customUrl.results.server";
import { useTimeFormat } from "~/hooks/useTimeFormat";
import { databaseTimestampToDate } from "~/utils/dates";
@@ -69,6 +70,7 @@ export function TeamResultsTable({ results }: TeamResultsTableProps) {
>
{result.tournamentName}
+ {result.tier ?
diff --git a/app/features/team/routes/t.$customUrl.edit.tsx b/app/features/team/routes/t.$customUrl.edit.tsx
index fe9922686..a35d5d9ae 100644
--- a/app/features/team/routes/t.$customUrl.edit.tsx
+++ b/app/features/team/routes/t.$customUrl.edit.tsx
@@ -229,7 +229,7 @@ function BioTextarea() {
const [value, setValue] = React.useState(team.bio ?? "");
return (
-
+
setValue(e.target.value)}
maxLength={TEAM.BIO_MAX_LENGTH}
data-testid="bio-textarea"
+ className="w-full"
/>
);
diff --git a/app/features/team/team-schemas.server.ts b/app/features/team/team-schemas.server.ts
index f6ec1db1f..1aa2f26ac 100644
--- a/app/features/team/team-schemas.server.ts
+++ b/app/features/team/team-schemas.server.ts
@@ -61,10 +61,6 @@ export const editTeamSchema = z.union([
falsyToNull,
z.string().max(TEAM.TAG_MAX_LENGTH).nullable(),
),
- customTheme: z.preprocess(
- (val) => (!val || val === "null" ? null : val),
- themeInputSchema.nullable(),
- ),
}),
]);
diff --git a/app/features/tier-list-maker/components/DraggableItem.module.css b/app/features/tier-list-maker/components/DraggableItem.module.css
index 63c88faa1..e22f2d388 100644
--- a/app/features/tier-list-maker/components/DraggableItem.module.css
+++ b/app/features/tier-list-maker/components/DraggableItem.module.css
@@ -1,4 +1,5 @@
.item {
+ min-height: 50px;
cursor: move;
touch-action: none;
user-select: none;
diff --git a/app/features/tier-list-maker/components/TierRow.module.css b/app/features/tier-list-maker/components/TierRow.module.css
index c413db4bd..ab2e091a0 100644
--- a/app/features/tier-list-maker/components/TierRow.module.css
+++ b/app/features/tier-list-maker/components/TierRow.module.css
@@ -28,7 +28,9 @@
.tierName {
color: var(--color-text-inverse);
line-height: 1.2;
- white-space: nowrap;
+ max-width: 90px;
+ overflow-wrap: break-word;
+ word-wrap: break-word;
}
.popupContent {
diff --git a/app/features/tier-list-maker/components/TierRow.tsx b/app/features/tier-list-maker/components/TierRow.tsx
index 73d25d459..c4cc36b33 100644
--- a/app/features/tier-list-maker/components/TierRow.tsx
+++ b/app/features/tier-list-maker/components/TierRow.tsx
@@ -5,6 +5,7 @@ import {
} from "@dnd-kit/sortable";
import clsx from "clsx";
import { ChevronDown, ChevronUp, Trash } from "lucide-react";
+import { useLayoutEffect, useRef } from "react";
import { Button } from "react-aria-components";
import { useTranslation } from "react-i18next";
import { SendouButton } from "~/components/elements/Button";
@@ -28,6 +29,7 @@ interface TierRowProps {
export function TierRow({ tier }: TierRowProps) {
const {
state,
+ activeItem,
getItemsInTier,
handleRemoveTier,
handleRenameTier,
@@ -44,6 +46,11 @@ export function TierRow({ tier }: TierRowProps) {
id: tier.id,
});
+ const combinedRef = useLockedHeightWhileDragging({
+ setNodeRef,
+ isDragging: activeItem !== null,
+ });
+
const tierIndex = state.tiers.findIndex((t) => t.id === tier.id);
const isFirstTier = tierIndex === 0;
const isLastTier = tierIndex === state.tiers.length - 1;
@@ -121,7 +128,7 @@ export function TierRow({ tier }: TierRowProps) {
) : null}
void;
+ isDragging: boolean;
+}) {
+ const ref = useRef(null);
+
+ const combinedRef = (node: HTMLDivElement | null) => {
+ ref.current = node;
+ setNodeRef(node);
+ };
+
+ useLayoutEffect(() => {
+ const el = ref.current;
+ if (!el) return;
+
+ if (isDragging) {
+ const rect = el.getBoundingClientRect();
+ const firstItem = el.firstElementChild;
+ const topOffset = firstItem
+ ? firstItem.getBoundingClientRect().top - rect.top
+ : undefined;
+
+ el.style.height = `${rect.height}px`;
+ el.style.overflow = "hidden";
+
+ if (topOffset !== undefined) {
+ el.style.alignContent = "flex-start";
+ el.style.paddingTop = `${topOffset}px`;
+ }
+ } else {
+ el.style.height = "";
+ el.style.overflow = "";
+ el.style.alignContent = "";
+ el.style.paddingTop = "";
+ }
+ }, [isDragging]);
+
+ return combinedRef;
+}
+
function tierNameFontSize(name: string) {
const length = name.length;
for (const breakpoint of TIER_NAME_FONT_SIZE_BREAKPOINTS) {
diff --git a/app/features/tier-list-maker/routes/tier-list-maker.module.css b/app/features/tier-list-maker/routes/tier-list-maker.module.css
index 1d160f435..d12c1c2dd 100644
--- a/app/features/tier-list-maker/routes/tier-list-maker.module.css
+++ b/app/features/tier-list-maker/routes/tier-list-maker.module.css
@@ -70,7 +70,6 @@
font-weight: var(--weight-bold);
color: var(--color-text-high);
text-transform: lowercase;
- white-space: nowrap;
}
.authorInfo {
@@ -83,5 +82,4 @@
font-weight: var(--weight-bold);
font-size: var(--font-xs);
color: var(--color-text);
- white-space: nowrap;
}
diff --git a/app/features/tier-list-maker/routes/tier-list-maker.tsx b/app/features/tier-list-maker/routes/tier-list-maker.tsx
index ceea0554a..6acdc6e15 100644
--- a/app/features/tier-list-maker/routes/tier-list-maker.tsx
+++ b/app/features/tier-list-maker/routes/tier-list-maker.tsx
@@ -162,6 +162,7 @@ function TierListMakerContent() {
>;
+export async function findMatchById(id: number) {
+ const row = await db
+ .selectFrom("TournamentMatch")
+ .innerJoin(
+ "TournamentStage",
+ "TournamentStage.id",
+ "TournamentMatch.stageId",
+ )
+ .innerJoin(
+ "TournamentRound",
+ "TournamentRound.id",
+ "TournamentMatch.roundId",
+ )
+ .innerJoin("Tournament", "Tournament.id", "TournamentStage.tournamentId")
+ .select(({ eb }) => [
+ "TournamentMatch.id",
+ "TournamentMatch.groupId",
+ "TournamentMatch.opponentOne",
+ "TournamentMatch.opponentTwo",
+ "TournamentMatch.chatCode",
+ "TournamentMatch.startedAt",
+ "TournamentMatch.status",
+ "Tournament.mapPickingStyle",
+ "TournamentRound.id as roundId",
+ "TournamentRound.maps as roundMaps",
+ jsonArrayFrom(
+ eb
+ .selectFrom("TournamentTeamMember")
+ .innerJoin("User", "User.id", "TournamentTeamMember.userId")
+ .select([
+ "User.id",
+ "User.username",
+ "TournamentTeamMember.tournamentTeamId",
+ sql<
+ string | null
+ >`coalesce("TournamentTeamMember"."inGameName", "User"."inGameName")`.as(
+ "inGameName",
+ ),
+ "User.discordId",
+ "User.customUrl",
+ "User.discordAvatar",
+ "User.pronouns",
+ ])
+ .where(({ or, eb: innerEb }) =>
+ or([
+ innerEb(
+ "TournamentTeamMember.tournamentTeamId",
+ "=",
+ sql`"TournamentMatch"."opponentOne" ->> '$.id'`,
+ ),
+ innerEb(
+ "TournamentTeamMember.tournamentTeamId",
+ "=",
+ sql`"TournamentMatch"."opponentTwo" ->> '$.id'`,
+ ),
+ ]),
+ ),
+ ).as("players"),
+ ])
+ .where("TournamentMatch.id", "=", id)
+ .executeTakeFirst();
+
+ if (!row) return;
+
+ return {
+ ...row,
+ bestOf: row.roundMaps.count,
+ };
+}
export function findResultById(id: number) {
return db
diff --git a/app/features/tournament-bracket/actions/to.$id.brackets.server.ts b/app/features/tournament-bracket/actions/to.$id.brackets.server.ts
index bc7c58f03..fc5c039ab 100644
--- a/app/features/tournament-bracket/actions/to.$id.brackets.server.ts
+++ b/app/features/tournament-bracket/actions/to.$id.brackets.server.ts
@@ -10,6 +10,7 @@ import {
import { createSwissBracketInTransaction } from "~/features/tournament/queries/createSwissBracketInTransaction.server";
import { updateRoundMaps } from "~/features/tournament/queries/updateRoundMaps.server";
import * as TournamentRepository from "~/features/tournament/TournamentRepository.server";
+import * as TournamentTeamRepository from "~/features/tournament/TournamentTeamRepository.server";
import * as Progression from "~/features/tournament-bracket/core/Progression";
import invariant from "~/utils/invariant";
import { logger } from "~/utils/logger";
@@ -22,6 +23,7 @@ import {
import { assertUnreachable } from "~/utils/types";
import { idObject } from "~/utils/zod";
import type { PreparedMaps } from "../../../db/tables";
+import * as AbDivisions from "../core/AbDivisions";
import { getServerTournamentManager } from "../core/brackets-manager/manager.server";
import { roundMapsFromInput } from "../core/mapList.server";
import * as PreparedMapsUtils from "../core/PreparedMaps";
@@ -84,6 +86,11 @@ export const action: ActionFunction = async ({ params, request }) => {
})
: data.maps;
+ const abDivisions =
+ bracket.type === "round_robin" && bracket.settings?.hasAbDivisions
+ ? abDivisionsForSeeding(seeding, tournament, groupCount)
+ : undefined;
+
errorToastIfFalsy(
bracket.type === "round_robin" || bracket.type === "swiss"
? bracket.data.round.length / groupCount === maps.length
@@ -111,6 +118,7 @@ export const action: ActionFunction = async ({ params, request }) => {
? seeding
: fillWithNullTillPowerOfTwo(seeding),
settings,
+ abDivisions,
});
updateRoundMaps(
@@ -287,9 +295,8 @@ export const action: ActionFunction = async ({ params, request }) => {
`Checking in (bracket try): tournament team id: ${teamMemberOf.id} - user id: ${user.id} - tournament id: ${tournament.ctx.id} - bracket idx: ${data.bracketIdx}`,
);
- await TournamentRepository.checkIn({
+ await TournamentTeamRepository.checkIn(teamMemberOf.id, {
bracketIdx: data.bracketIdx,
- tournamentTeamId: teamMemberOf.id,
});
logger.info(
@@ -358,6 +365,23 @@ function errorToastIfFalsyNoFollowUpBrackets(tournament: Tournament) {
);
}
+function abDivisionsForSeeding(
+ seeding: number[],
+ tournament: Tournament,
+ groupCount: number,
+): (0 | 1)[] {
+ const abDivisionsBySeedOrder = seeding.map((teamId) => {
+ const team = tournament.teamById(teamId);
+ errorToastIfFalsy(team, "Team not found when building A/B divisions");
+ return team.abDivision;
+ });
+
+ const result = AbDivisions.validate({ abDivisionsBySeedOrder, groupCount });
+ errorToastIfErr(result);
+
+ return result.value;
+}
+
function adjustLinkedRounds({
maps,
thirdPlaceMatchLinked,
diff --git a/app/features/tournament-bracket/actions/to.$id.matches.$mid.server.ts b/app/features/tournament-bracket/actions/to.$id.matches.$mid.server.ts
index ec8a02ad9..33967e7fb 100644
--- a/app/features/tournament-bracket/actions/to.$id.matches.$mid.server.ts
+++ b/app/features/tournament-bracket/actions/to.$id.matches.$mid.server.ts
@@ -29,14 +29,11 @@ import { deleteMatchPickBanEvents } from "../queries/deleteMatchPickBanEvents.se
import { deleteParticipantsByMatchGameResultId } from "../queries/deleteParticipantsByMatchGameResultId.server";
import { deletePickBanEvent } from "../queries/deletePickBanEvent.server";
import { deleteTournamentMatchGameResultById } from "../queries/deleteTournamentMatchGameResultById.server";
-import {
- type FindMatchById,
- findMatchById,
-} from "../queries/findMatchById.server";
import { findResultsByMatchId } from "../queries/findResultsByMatchId.server";
import { insertTournamentMatchGameResult } from "../queries/insertTournamentMatchGameResult.server";
import { insertTournamentMatchGameResultParticipant } from "../queries/insertTournamentMatchGameResultParticipant.server";
import { updateMatchGameResultPoints } from "../queries/updateMatchGameResultPoints.server";
+import type { FindMatchById } from "../TournamentMatchRepository.server";
import {
matchPageParamsSchema,
matchSchema,
@@ -56,7 +53,9 @@ export const action: ActionFunction = async ({ params, request }) => {
params,
schema: matchPageParamsSchema,
});
- const match = notFoundIfFalsy(findMatchById(matchId));
+ const match = notFoundIfFalsy(
+ await TournamentMatchRepository.findMatchById(matchId),
+ );
const data = await parseRequestPayload({
request,
schema: matchSchema,
@@ -113,6 +112,7 @@ export const action: ActionFunction = async ({ params, request }) => {
let emitMatchUpdate = false;
let emitTournamentUpdate = false;
+ let endedDroppedMatchIds: number[] = [];
switch (data._action) {
case "REPORT_SCORE": {
@@ -156,7 +156,13 @@ export const action: ActionFunction = async ({ params, request }) => {
"Points are invalid (winner must have more points than loser)",
);
- // TODO: could also validate that if bracket demands it then points are defined
+ const bracket = tournament.bracketByIdx(
+ tournament.matchIdToBracketIdx(match.id)!,
+ )!;
+ errorToastIfFalsy(
+ !bracket.collectResultsWithPoints || data.points,
+ "Points are required for this bracket",
+ );
scores[scoreToIncrement()]++;
@@ -225,7 +231,10 @@ export const action: ActionFunction = async ({ params, request }) => {
}
if (setOver) {
- endDroppedTeamMatches({ tournament, manager });
+ endedDroppedMatchIds = endDroppedTeamMatches({
+ tournament,
+ manager,
+ });
}
})();
@@ -710,6 +719,11 @@ export const action: ActionFunction = async ({ params, request }) => {
result: winnerTeamId === match.opponentTwo!.id ? "win" : "loss",
},
});
+
+ endedDroppedMatchIds = endDroppedTeamMatches({
+ tournament,
+ manager,
+ });
})();
emitMatchUpdate = true;
@@ -732,6 +746,11 @@ export const action: ActionFunction = async ({ params, request }) => {
type: "TOURNAMENT_MATCH_UPDATED",
revalidateOnly: true,
},
+ ...endedDroppedMatchIds.map((id) => ({
+ room: tournamentMatchWebsocketRoom(id),
+ type: "TOURNAMENT_MATCH_UPDATED" as const,
+ revalidateOnly: true as const,
+ })),
]);
}
if (emitTournamentUpdate) {
diff --git a/app/features/tournament-bracket/components/Bracket/PlacementsTable.tsx b/app/features/tournament-bracket/components/Bracket/PlacementsTable.tsx
index 1a6873ef6..4af034d9b 100644
--- a/app/features/tournament-bracket/components/Bracket/PlacementsTable.tsx
+++ b/app/features/tournament-bracket/components/Bracket/PlacementsTable.tsx
@@ -8,7 +8,7 @@ import { logger } from "../../../../utils/logger";
import { tournamentTeamPage } from "../../../../utils/urls";
import { useUser } from "../../../auth/core/user";
import { TOURNAMENT } from "../../../tournament/tournament-constants";
-import type { Bracket } from "../../core/Bracket";
+import type { Bracket, Standing } from "../../core/Bracket";
import * as Progression from "../../core/Progression";
import * as Swiss from "../../core/Swiss";
import styles from "./bracket.module.css";
@@ -75,9 +75,8 @@ export function PlacementsTable({
return a.placement - b.placement;
});
- const destinationBracket = (placement: number) => {
+ const destinationBracket = (standing: Standing, placement: number) => {
if (bracket.type === "swiss" && bracket.settings?.advanceThreshold) {
- const standing = standings[placement - 1];
const stats = standing.stats;
invariant(stats);
@@ -125,11 +124,83 @@ export function PlacementsTable({
);
})();
+ if (bracket.settings?.hasAbDivisions) {
+ const aStandings = standings.filter((s) => s.team.abDivision === 0);
+ const bStandings = standings.filter((s) => s.team.abDivision === 1);
+
+ if (aStandings.length === 0 && bStandings.length === 0) {
+ return null;
+ }
+
+ return (
+
+ {aStandings.length > 0 ? (
+
+ );
+ }
+
+ if (standings.length === 0) {
+ return null;
+ }
+
+ return (
+
+
Team
@@ -179,7 +250,7 @@ export function PlacementsTable({
const team = bracket.tournament.teamById(s.team.id);
- const dest = destinationBracket(i + 1);
+ const dest = destinationBracket(s, i + 1);
const overridenDestination =
bracket.tournament.ctx.bracketProgressionOverrides.find(
diff --git a/app/features/tournament-bracket/components/BracketMapListDialog.module.css b/app/features/tournament-bracket/components/BracketMapListDialog.module.css
index 74bb71aae..c1cb48e72 100644
--- a/app/features/tournament-bracket/components/BracketMapListDialog.module.css
+++ b/app/features/tournament-bracket/components/BracketMapListDialog.module.css
@@ -86,31 +86,27 @@
text-align: start;
}
-.mapSelectContainer {
- display: flex;
- gap: var(--s-2);
+.mapRowSelect {
+ flex: 1;
font-size: var(--font-sm);
font-weight: var(--weight-semi);
+
+ & > button {
+ height: auto;
+ padding: 0;
+ border: none;
+ background-color: transparent;
+ }
+}
+
+.mapRowSelectPopover {
+ min-width: 18rem;
+}
+
+.mapSelectItem {
+ display: flex;
align-items: center;
- position: relative;
- flex: 1;
-}
-
-.mapSelect {
- position: absolute;
- left: 0;
- top: 0;
- width: 100%;
- height: 100%;
- opacity: 0;
- cursor: pointer;
-}
-
-.mapSelectIcon {
- width: 1.25rem;
- height: 1.25rem;
- color: var(--color-text-high);
- margin-left: auto;
+ gap: var(--s-2);
}
.infoPopover {
diff --git a/app/features/tournament-bracket/components/BracketMapListDialog.tsx b/app/features/tournament-bracket/components/BracketMapListDialog.tsx
index 4d7b4490d..97027c1fe 100644
--- a/app/features/tournament-bracket/components/BracketMapListDialog.tsx
+++ b/app/features/tournament-bracket/components/BracketMapListDialog.tsx
@@ -1,6 +1,5 @@
import clsx from "clsx";
import {
- ChevronsUpDown,
Link as LinkIcon,
Minus,
MousePointerClick,
@@ -12,6 +11,11 @@ import * as React from "react";
import { useTranslation } from "react-i18next";
import { type FetcherWithComponents, Link, useFetcher } from "react-router";
import { SendouDialog } from "~/components/elements/Dialog";
+import {
+ SendouSelect,
+ SendouSelectItem,
+ SendouSelectItemSection,
+} from "~/components/elements/Select";
import { ModeImage, StageImage } from "~/components/Image";
import { InfoPopover } from "~/components/InfoPopover";
import { Input } from "~/components/Input";
@@ -1060,9 +1064,30 @@ function MapListRow({
hoveredMap: string | null;
onMapChange: (map: NonNullable[number]) => void;
}) {
- const { t } = useTranslation(["game-misc"]);
+ const { t } = useTranslation(["common", "game-misc"]);
const tournament = useTournament();
+ const items = modesShort.flatMap((mode) => {
+ const mapsForMode = tournament.ctx.toSetMapPool.filter(
+ (m) => m.mode === mode,
+ );
+
+ if (mapsForMode.length === 0) return [];
+
+ return [
+ {
+ key: mode,
+ modeLabel: t(`game-misc:MODE_LONG_${mode}`),
+ maps: mapsForMode.map((m) => ({
+ id: serializedMapMode(m),
+ mode,
+ stageId: m.stageId,
+ name: t(`game-misc:STAGE_${m.stageId}`),
+ })),
+ },
+ ];
+ });
+
return (
onHoverMap(serializedMapMode(map))}
>
-
- {number}.
- {
- const [mode, stageId] = e.target.value.split("-");
- onMapChange({
- mode: mode as ModeShort,
- stageId: Number(stageId) as StageId,
- });
- }}
- >
- {modesShort.map((mode) => {
- const mapsForMode = tournament.ctx.toSetMapPool.filter(
- (m) => m.mode === mode,
- );
-
- if (mapsForMode.length === 0) return null;
-
- return (
-
- {mapsForMode.map((m) => (
-
- {t(`game-misc:MODE_SHORT_${mode}`)}{" "}
- {t(`game-misc:STAGE_${m.stageId}`)}
-
- ))}
-
- );
- })}
-
-
+ {number}.
+ {
+ if (key === null) return;
+ const [mode, stageId] = String(key).split("-");
+ onMapChange({
+ mode: mode as ModeShort,
+ stageId: Number(stageId) as StageId,
+ });
+ }}
+ search={{
+ placeholder: t("common:forms.stageSearch.search.placeholder"),
+ }}
+ className={styles.mapRowSelect}
+ popoverClassName={styles.mapRowSelectPopover}
+ >
+ {(group) => (
+
+ {group.maps.map((m) => (
+
+
+ {m.name}
+
+
+ ))}
+
+ )}
+
);
}
diff --git a/app/features/tournament-bracket/components/MatchMapInfo.tsx b/app/features/tournament-bracket/components/MatchMapInfo.tsx
index e1a1f5c82..a53055e93 100644
--- a/app/features/tournament-bracket/components/MatchMapInfo.tsx
+++ b/app/features/tournament-bracket/components/MatchMapInfo.tsx
@@ -3,6 +3,7 @@ import { useLoaderData } from "react-router";
import { ModeImage, StageImage } from "~/components/Image";
import type { CustomPickBanStep } from "~/db/tables";
import { useTournament } from "~/features/tournament/routes/to.$id";
+import * as PickBan from "~/features/tournament-bracket/core/PickBan";
import type { ModeShort, StageId } from "~/modules/in-game-lists/types";
import type { TournamentMatchLoaderData } from "../loaders/to.$id.matches.$mid.server";
import styles from "./MatchMapInfo.module.css";
@@ -17,6 +18,11 @@ export function MatchMapInfo({ teams }: { teams: [number, number] }) {
const customFlow = data.match.roundMaps?.customFlow;
if (!customFlow) return null;
+ const pickBanTeams: [PickBan.PickBanTeam, PickBan.PickBanTeam] = [
+ { id: teams[0], seed: teamOne?.seed ?? 0 },
+ { id: teams[1], seed: teamTwo?.seed ?? 0 },
+ ];
+
const teamOneBans: BanEvent[] = [];
const teamTwoBans: BanEvent[] = [];
@@ -28,7 +34,7 @@ export function MatchMapInfo({ teams }: { teams: [number, number] }) {
eventIndex: i,
preSet: customFlow.preSet,
postGame: customFlow.postGame,
- teams,
+ teams: pickBanTeams,
results: data.results,
});
@@ -60,7 +66,7 @@ function resolveTeamForEvent({
eventIndex: number;
preSet: CustomPickBanStep[];
postGame: CustomPickBanStep[];
- teams: [number, number];
+ teams: [PickBan.PickBanTeam, PickBan.PickBanTeam];
results: Array<{ winnerTeamId: number }>;
}): number | null {
const step =
@@ -70,27 +76,27 @@ function resolveTeamForEvent({
if (!step?.side) return null;
- switch (step.side) {
- case "ALPHA":
- return teams[0];
- case "BRAVO":
- return teams[1];
- case "HIGHER_SEED":
- return teams[1];
- case "LOWER_SEED":
- return teams[0];
- case "WINNER":
- case "LOSER": {
- const cycleIndex = Math.floor(
- (eventIndex - preSet.length) / postGame.length,
- );
- const result = results[cycleIndex];
- if (!result) return null;
+ // PickBan.resolveTeamFromSide uses the last element of results for WINNER/LOSER,
+ // but here we iterate over all historical events so we need to slice
+ // results to the correct post-game cycle
+ if (step.side === "WINNER" || step.side === "LOSER") {
+ const cycleIndex = Math.floor(
+ (eventIndex - preSet.length) / postGame.length,
+ );
+ if (!results[cycleIndex]) return null;
- if (step.side === "WINNER") return result.winnerTeamId;
- return teams.find((t) => t !== result.winnerTeamId) ?? null;
- }
+ return PickBan.resolveTeamFromSide({
+ side: step.side,
+ teams,
+ results: results.slice(0, cycleIndex + 1),
+ });
}
+
+ return PickBan.resolveTeamFromSide({
+ side: step.side,
+ teams,
+ results,
+ });
}
interface BanEvent {
diff --git a/app/features/tournament-bracket/core/AbDivisions.test.ts b/app/features/tournament-bracket/core/AbDivisions.test.ts
new file mode 100644
index 000000000..9c62b82bd
--- /dev/null
+++ b/app/features/tournament-bracket/core/AbDivisions.test.ts
@@ -0,0 +1,119 @@
+import { describe, expect, it } from "vitest";
+import * as AbDivisions from "./AbDivisions";
+
+describe("AbDivisions.validate", () => {
+ it("accepts a balanced 12-team single-group configuration", () => {
+ const result = AbDivisions.validate({
+ abDivisionsBySeedOrder: [0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1],
+ groupCount: 1,
+ });
+
+ expect(result.isOk()).toBe(true);
+ expect(result._unsafeUnwrap()).toEqual([
+ 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1,
+ ]);
+ });
+
+ it("accepts a balanced 12-team two-group configuration", () => {
+ const result = AbDivisions.validate({
+ abDivisionsBySeedOrder: [0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1],
+ groupCount: 2,
+ });
+
+ expect(result.isOk()).toBe(true);
+ });
+
+ it("rejects any unassigned team", () => {
+ const result = AbDivisions.validate({
+ abDivisionsBySeedOrder: [0, 1, 0, 1, 0, null, 0, 1, 0, 1, 0, 1],
+ groupCount: 1,
+ });
+
+ expect(result.isErr()).toBe(true);
+ expect(result._unsafeUnwrapErr()).toMatch(/assigned/);
+ });
+
+ it("rejects invalid division values", () => {
+ const result = AbDivisions.validate({
+ abDivisionsBySeedOrder: [0, 1, 0, 1, 0, 2, 0, 1, 0, 1, 0, 1],
+ groupCount: 1,
+ });
+
+ expect(result.isErr()).toBe(true);
+ });
+
+ it("rejects A/B counts differing by more than 1", () => {
+ const result = AbDivisions.validate({
+ abDivisionsBySeedOrder: [0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1],
+ groupCount: 1,
+ });
+
+ expect(result.isErr()).toBe(true);
+ expect(result._unsafeUnwrapErr()).toMatch(/7 A, 5 B/);
+ });
+
+ it("accepts a ±1 uneven configuration with a single group", () => {
+ const result = AbDivisions.validate({
+ abDivisionsBySeedOrder: [0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0],
+ groupCount: 1,
+ });
+
+ expect(result.isOk()).toBe(true);
+ });
+
+ it("rejects a ±1 uneven configuration when there are multiple groups", () => {
+ const result = AbDivisions.validate({
+ abDivisionsBySeedOrder: [0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0],
+ groupCount: 2,
+ });
+
+ expect(result.isErr()).toBe(true);
+ expect(result._unsafeUnwrapErr()).toMatch(/single group/);
+ });
+
+ it("rejects team counts not divisible by group count", () => {
+ const result = AbDivisions.validate({
+ abDivisionsBySeedOrder: [0, 1, 0, 1, 0, 1, 0, 1, 0, 1],
+ groupCount: 3,
+ });
+
+ expect(result.isErr()).toBe(true);
+ expect(result._unsafeUnwrapErr()).toMatch(/10 checked-in teams into 3/);
+ });
+
+ it("rejects odd per-group team counts", () => {
+ const result = AbDivisions.validate({
+ abDivisionsBySeedOrder: [0, 1, 0, 1, 0, 1, 0, 1, 0, 1],
+ groupCount: 2,
+ });
+
+ expect(result.isErr()).toBe(true);
+ expect(result._unsafeUnwrapErr()).toMatch(/5 teams/);
+ });
+
+ it("preserves the original order of the divisions", () => {
+ const divisions = [1, 0, 1, 0, 0, 1, 1, 0];
+
+ const result = AbDivisions.validate({
+ abDivisionsBySeedOrder: divisions,
+ groupCount: 2,
+ });
+
+ expect(result._unsafeUnwrap()).toEqual(divisions);
+ });
+});
+
+describe("AbDivisions.countByDivision", () => {
+ it("counts A, B, and unassigned separately", () => {
+ const counts = AbDivisions.countByDivision([
+ { abDivision: 0 },
+ { abDivision: 0 },
+ { abDivision: 1 },
+ { abDivision: null },
+ { abDivision: null },
+ { abDivision: null },
+ ]);
+
+ expect(counts).toEqual({ a: 2, b: 1, unassigned: 3 });
+ });
+});
diff --git a/app/features/tournament-bracket/core/AbDivisions.ts b/app/features/tournament-bracket/core/AbDivisions.ts
new file mode 100644
index 000000000..936c7e632
--- /dev/null
+++ b/app/features/tournament-bracket/core/AbDivisions.ts
@@ -0,0 +1,85 @@
+import { err, ok, type Result } from "neverthrow";
+
+interface ValidateArgs {
+ abDivisionsBySeedOrder: (number | null | undefined)[];
+ groupCount: number;
+}
+
+/**
+ * Validates that the checked-in teams are ready to start a bipartite (A/B) round robin bracket.
+ *
+ * Returns the division assignments parallel to the seeding order on success, or an error message
+ * suitable for surfacing to the organizer if any of the following are violated:
+ *
+ * - Every team has an A (0) or B (1) assignment
+ * - The counts of A and B teams differ by at most 1
+ * - When the counts differ by 1, there must be only one group (uneven divisions can't be split
+ * evenly across multiple groups)
+ * - When the counts are equal, the total team count splits evenly across the groups and each
+ * group's team count is even (so A and B can be balanced within the group)
+ */
+export function validate({
+ abDivisionsBySeedOrder,
+ groupCount,
+}: ValidateArgs): Result<(0 | 1)[], string> {
+ const teamCount = abDivisionsBySeedOrder.length;
+
+ const missingAssignment = abDivisionsBySeedOrder.some(
+ (division) => division !== 0 && division !== 1,
+ );
+ if (missingAssignment) {
+ return err(
+ "Every checked-in team must be assigned to A or B before starting the bracket",
+ );
+ }
+
+ const aCount = abDivisionsBySeedOrder.filter(
+ (division) => division === 0,
+ ).length;
+ const bCount = abDivisionsBySeedOrder.filter(
+ (division) => division === 1,
+ ).length;
+ const diff = Math.abs(aCount - bCount);
+
+ if (diff > 1) {
+ return err(
+ `Unbalanced A/B divisions (${aCount} A, ${bCount} B) — counts can differ by at most 1`,
+ );
+ }
+
+ if (diff === 1) {
+ if (groupCount !== 1) {
+ return err(
+ `Uneven A/B divisions (${aCount} A, ${bCount} B) are only supported with a single group`,
+ );
+ }
+
+ return ok(abDivisionsBySeedOrder as (0 | 1)[]);
+ }
+
+ if (teamCount % groupCount !== 0) {
+ return err(
+ `Can't evenly distribute ${teamCount} checked-in teams into ${groupCount} groups`,
+ );
+ }
+
+ const teamsPerGroup = teamCount / groupCount;
+ if (teamsPerGroup % 2 !== 0) {
+ return err(
+ `Each group would have ${teamsPerGroup} teams — must be even for A/B divisions`,
+ );
+ }
+
+ return ok(abDivisionsBySeedOrder as (0 | 1)[]);
+}
+
+/** Counts checked-in teams by division. Unassigned teams are excluded. */
+export function countByDivision(teams: { abDivision: number | null }[]) {
+ const a = teams.filter((team) => team.abDivision === 0).length;
+ const b = teams.filter((team) => team.abDivision === 1).length;
+ const unassigned = teams.filter(
+ (team) => team.abDivision !== 0 && team.abDivision !== 1,
+ ).length;
+
+ return { a, b, unassigned };
+}
diff --git a/app/features/tournament-bracket/core/Bracket.test.ts b/app/features/tournament-bracket/core/Bracket.test.ts
index d0e2d9e41..88d1ef665 100644
--- a/app/features/tournament-bracket/core/Bracket.test.ts
+++ b/app/features/tournament-bracket/core/Bracket.test.ts
@@ -1,11 +1,13 @@
import * as R from "remeda";
import { describe, expect, it } from "vitest";
+import { BracketsManager } from "~/modules/brackets-manager";
+import { InMemoryDatabase } from "~/modules/brackets-memory-db";
import invariant from "../../../utils/invariant";
import * as Swiss from "../core/Swiss";
import { Tournament } from "./Tournament";
import { PADDLING_POOL_255 } from "./tests/mocks";
import { LOW_INK_DECEMBER_2024 } from "./tests/mocks-li";
-import { testTournament } from "./tests/test-utils";
+import { testTournament, tournamentCtxTeam } from "./tests/test-utils";
const TEAM_ERROR_404_ID = 17354;
const TEAM_THIS_IS_FINE_ID = 17513;
@@ -168,3 +170,124 @@ describe("round robin standings", () => {
}
});
});
+
+describe("round robin A/B divisions standings", () => {
+ const abDivisionsTournament = () => {
+ const storage = new InMemoryDatabase();
+ const manager = new BracketsManager(storage);
+
+ manager.create({
+ name: "AB RR",
+ tournamentId: 1,
+ type: "round_robin",
+ seeding: [1, 2, 3, 4],
+ abDivisions: [0, 1, 0, 1],
+ settings: {
+ groupCount: 1,
+ hasAbDivisions: true,
+ seedOrdering: ["groups.seed_optimized"],
+ },
+ });
+
+ const setResult = (
+ matchId: number,
+ winnerId: number,
+ winnerScore: number,
+ loserScore: number,
+ ) => {
+ const match = storage.select("match", matchId);
+ invariant(match, `match ${matchId} not found`);
+ const winnerIsOpp1 = match.opponent1.id === winnerId;
+ manager.update.match({
+ id: match.id,
+ opponent1: winnerIsOpp1
+ ? { score: winnerScore, result: "win" }
+ : { score: loserScore },
+ opponent2: winnerIsOpp1
+ ? { score: loserScore }
+ : { score: winnerScore, result: "win" },
+ });
+ };
+
+ const winnerByMatchup: Record = {
+ "1-2": 1,
+ "1-4": 1,
+ "2-3": 2,
+ "3-4": 3,
+ };
+ for (const match of storage.select("match")!) {
+ const a = match.opponent1.id as number;
+ const b = match.opponent2.id as number;
+ const key = a < b ? `${a}-${b}` : `${b}-${a}`;
+ const winnerId = winnerByMatchup[key];
+ invariant(winnerId, `unexpected matchup ${key}`);
+ const loserScore = key === "2-3" || key === "3-4" ? 1 : 0;
+ setResult(match.id, winnerId, 2, loserScore);
+ }
+
+ const data = manager.get.tournamentData(1);
+
+ return testTournament({
+ ctx: {
+ settings: {
+ bracketProgression: [
+ {
+ type: "round_robin",
+ name: "AB RR",
+ requiresCheckIn: false,
+ settings: { hasAbDivisions: true },
+ },
+ ],
+ },
+ teams: [
+ tournamentCtxTeam(1, { abDivision: 0, seed: 1 }),
+ tournamentCtxTeam(2, { abDivision: 1, seed: 2 }),
+ tournamentCtxTeam(3, { abDivision: 0, seed: 3 }),
+ tournamentCtxTeam(4, { abDivision: 1, seed: 4 }),
+ ],
+ },
+ data,
+ });
+ };
+
+ it("filtering by abDivision preserves standard tiebreaker order within each division", () => {
+ const tournament = abDivisionsTournament();
+ const standings = tournament.bracketByIdx(0)!.currentStandings(true);
+
+ expect(standings.map((s) => s.team.id)).toEqual([1, 2, 3, 4]);
+
+ const divisionA = standings.filter((s) => s.team.abDivision === 0);
+ const divisionB = standings.filter((s) => s.team.abDivision === 1);
+
+ expect(divisionA.map((s) => s.team.id)).toEqual([1, 3]);
+ expect(divisionB.map((s) => s.team.id)).toEqual([2, 4]);
+ });
+
+ it("source({ placements: [1] }) returns top team from each division", () => {
+ const tournament = abDivisionsTournament();
+ const { teams } = tournament.bracketByIdx(0)!.source({ placements: [1] });
+
+ expect(teams).toEqual([1, 2]);
+ });
+
+ it("source({ placements: [1, 2] }) returns top two teams from each division", () => {
+ const tournament = abDivisionsTournament();
+ const { teams } = tournament
+ .bracketByIdx(0)!
+ .source({ placements: [1, 2] });
+
+ expect(teams).toHaveLength(4);
+ expect(new Set(teams)).toEqual(new Set([1, 2, 3, 4]));
+ expect(teams.slice(0, 2)).toEqual([1, 3]);
+ expect(teams.slice(2, 4)).toEqual([2, 4]);
+ });
+
+ it("source ignores placements beyond division size", () => {
+ const tournament = abDivisionsTournament();
+ const { teams } = tournament
+ .bracketByIdx(0)!
+ .source({ placements: [1, 5] });
+
+ expect(teams).toEqual([1, 2]);
+ });
+});
diff --git a/app/features/tournament-bracket/core/Bracket/Bracket.ts b/app/features/tournament-bracket/core/Bracket/Bracket.ts
index 3fb29f9ba..56634639a 100644
--- a/app/features/tournament-bracket/core/Bracket/Bracket.ts
+++ b/app/features/tournament-bracket/core/Bracket/Bracket.ts
@@ -7,6 +7,7 @@ import type { Round } from "~/modules/brackets-model";
import invariant from "~/utils/invariant";
import { logger } from "~/utils/logger";
import { fillWithNullTillPowerOfTwo } from "../../tournament-bracket-utils";
+import * as AbDivisions from "../AbDivisions";
import { getTournamentManager } from "../brackets-manager";
import * as Progression from "../Progression";
import type { OptionalIdObject, Tournament } from "../Tournament";
@@ -294,6 +295,16 @@ export abstract class Bracket {
const virtualTournamentId = 1;
if (teams.length >= TOURNAMENT.ENOUGH_TEAMS_TO_START) {
+ const settings = this.tournament.bracketManagerSettings(
+ this.settings,
+ this.type,
+ teams.length,
+ );
+ const abDivisions =
+ this.type === "round_robin" && this.settings?.hasAbDivisions === true
+ ? this.abDivisionsForPreview(teams, settings.groupCount)
+ : undefined;
+
manager.create({
tournamentId: virtualTournamentId,
name: "Virtual",
@@ -302,17 +313,58 @@ export abstract class Bracket {
this.type === "round_robin"
? teams
: fillWithNullTillPowerOfTwo(teams),
- settings: this.tournament.bracketManagerSettings(
- this.settings,
- this.type,
- teams.length,
- ),
+ settings: abDivisions
+ ? settings
+ : {
+ ...settings,
+ hasAbDivisions: false,
+ },
+ abDivisions,
});
}
return manager.get.tournamentData(virtualTournamentId);
}
+ private abDivisionsForPreview(
+ teams: number[],
+ groupCount: number | undefined,
+ ): (0 | 1)[] | undefined {
+ if (!groupCount) return undefined;
+
+ const assignments = teams.map((teamId) => {
+ const team = this.tournament.teamById(teamId);
+ return team?.abDivision ?? null;
+ });
+
+ const allAssigned = assignments.every(
+ (value) => value === 0 || value === 1,
+ );
+ if (
+ allAssigned &&
+ AbDivisions.validate({
+ abDivisionsBySeedOrder: assignments,
+ groupCount,
+ }).isOk()
+ ) {
+ return assignments as (0 | 1)[];
+ }
+
+ const fakeAssignments: (0 | 1)[] = teams.map((_, index) =>
+ index % 2 === 0 ? 0 : 1,
+ );
+ if (
+ AbDivisions.validate({
+ abDivisionsBySeedOrder: fakeAssignments,
+ groupCount,
+ }).isOk()
+ ) {
+ return fakeAssignments;
+ }
+
+ return undefined;
+ }
+
get isUnderground() {
return Progression.isUnderground(
this.idx,
diff --git a/app/features/tournament-bracket/core/Bracket/RoundRobinBracket.ts b/app/features/tournament-bracket/core/Bracket/RoundRobinBracket.ts
index d3d612bcc..332517d0f 100644
--- a/app/features/tournament-bracket/core/Bracket/RoundRobinBracket.ts
+++ b/app/features/tournament-bracket/core/Bracket/RoundRobinBracket.ts
@@ -1,5 +1,6 @@
import * as R from "remeda";
import type { Tables } from "~/db/tables";
+import * as Standings from "~/features/tournament/core/Standings";
import type { TournamentManagerDataSet } from "~/modules/brackets-manager/types";
import invariant from "~/utils/invariant";
import { logger } from "~/utils/logger";
@@ -23,6 +24,13 @@ export class RoundRobinBracket extends Bracket {
const relevantMatchesFinished =
standings.length === this.participantTournamentTeamIds.length;
+ if (this.settings?.hasAbDivisions) {
+ return {
+ relevantMatchesFinished,
+ teams: this.teamsFromPlacementsPerAbDivision(standings, placements),
+ };
+ }
+
const uniquePlacements = R.unique(standings.map((s) => s.placement));
// 1,3,5 -> 1,2,3 e.g.
@@ -38,6 +46,30 @@ export class RoundRobinBracket extends Bracket {
};
}
+ private teamsFromPlacementsPerAbDivision(
+ standings: Standing[],
+ placements: number[],
+ ): number[] {
+ const groupIds = R.unique(
+ standings
+ .map((s) => s.groupId)
+ .filter((id): id is number => typeof id === "number"),
+ );
+ const teams: number[] = [];
+ for (const groupId of groupIds) {
+ for (const division of [0, 1] as const) {
+ const divisionStandings = standings.filter(
+ (s) => s.groupId === groupId && s.team.abDivision === division,
+ );
+ for (const placement of placements) {
+ const standing = divisionStandings[placement - 1];
+ if (standing) teams.push(standing.team.id);
+ }
+ }
+ }
+ return teams;
+ }
+
get standings(): Standing[] {
return this.currentStandings();
}
@@ -247,22 +279,8 @@ export class RoundRobinBracket extends Bracket {
return 0;
});
- let lastPlacement = 0;
- let currentPlacement = 1;
- let teamsEncountered = 0;
return this.standingsWithoutNonParticipants(
- sorted.map((team) => {
- if (team.placement !== lastPlacement) {
- lastPlacement = team.placement;
- currentPlacement = teamsEncountered + 1;
- }
- teamsEncountered++;
- return {
- ...team,
- placement: currentPlacement,
- stats: team.stats,
- };
- }),
+ Standings.reNumberPlacements(sorted),
);
}
diff --git a/app/features/tournament-bracket/core/Bracket/SwissBracket.ts b/app/features/tournament-bracket/core/Bracket/SwissBracket.ts
index f17006a6b..b1a6294eb 100644
--- a/app/features/tournament-bracket/core/Bracket/SwissBracket.ts
+++ b/app/features/tournament-bracket/core/Bracket/SwissBracket.ts
@@ -1,5 +1,6 @@
import * as R from "remeda";
import type { Tables } from "~/db/tables";
+import * as Standings from "~/features/tournament/core/Standings";
import { TOURNAMENT } from "~/features/tournament/tournament-constants";
import type { TournamentManagerDataSet } from "~/modules/brackets-manager/types";
import invariant from "~/utils/invariant";
@@ -443,22 +444,8 @@ export class SwissBracket extends Bracket {
return 0;
});
- let lastPlacement = 0;
- let currentPlacement = 1;
- let teamsEncountered = 0;
return this.standingsWithoutNonParticipants(
- sorted.map((team) => {
- if (team.placement !== lastPlacement) {
- lastPlacement = team.placement;
- currentPlacement = teamsEncountered + 1;
- }
- teamsEncountered++;
- return {
- ...team,
- placement: currentPlacement,
- stats: team.stats,
- };
- }),
+ Standings.reNumberPlacements(sorted),
);
}
diff --git a/app/features/tournament-bracket/core/Progression.test.ts b/app/features/tournament-bracket/core/Progression.test.ts
index 02f913b8d..85b5638bb 100644
--- a/app/features/tournament-bracket/core/Progression.test.ts
+++ b/app/features/tournament-bracket/core/Progression.test.ts
@@ -274,22 +274,36 @@ const getValidatedBrackets = (
);
describe("validatedSources - other rules", () => {
- it("handles NOT_RESOLVING_WINNER (only round robin)", () => {
- const error = getValidatedBrackets([
+ it("accepts a single round robin with no follow-ups", () => {
+ const result = getValidatedBrackets([
{
settings: {},
type: "round_robin",
},
- ]) as Progression.ValidationError;
+ ]);
- expect(error.type).toBe("NOT_RESOLVING_WINNER");
+ expect(Array.isArray(result)).toBe(true);
});
- it("handles NOT_RESOLVING_WINNER (ends in round robin)", () => {
- const error = getValidatedBrackets([
+ it("accepts a single A/B round robin with no follow-ups", () => {
+ const result = getValidatedBrackets([
+ {
+ settings: {
+ hasAbDivisions: true,
+ teamsPerGroup: 6,
+ },
+ type: "round_robin",
+ },
+ ]);
+
+ expect(Array.isArray(result)).toBe(true);
+ });
+
+ it("accepts a swiss to round robin progression", () => {
+ const result = getValidatedBrackets([
{
settings: {},
- type: "single_elimination",
+ type: "swiss",
},
{
settings: {},
@@ -301,9 +315,30 @@ describe("validatedSources - other rules", () => {
},
],
},
- ]) as Progression.ValidationError;
+ ]);
- expect(error.type).toBe("NOT_RESOLVING_WINNER");
+ expect(Array.isArray(result)).toBe(true);
+ });
+
+ it("accepts a round robin to round robin progression", () => {
+ const result = getValidatedBrackets([
+ {
+ settings: {},
+ type: "round_robin",
+ },
+ {
+ settings: {},
+ type: "round_robin",
+ sources: [
+ {
+ bracketId: "0",
+ placements: "1,2",
+ },
+ ],
+ },
+ ]);
+
+ expect(Array.isArray(result)).toBe(true);
});
it("handles NOT_RESOLVING_WINNER (swiss with many groups)", () => {
@@ -427,6 +462,55 @@ describe("validatedSources - other rules", () => {
expect(Array.isArray(result)).toBe(true);
});
+ it("flags TOO_MANY_PLACEMENTS on A/B divisions when placement exceeds per-division size", () => {
+ const error = getValidatedBrackets([
+ {
+ settings: {
+ hasAbDivisions: true,
+ teamsPerGroup: 6,
+ },
+ type: "round_robin",
+ },
+ {
+ settings: {},
+ type: "single_elimination",
+ sources: [
+ {
+ bracketId: "0",
+ placements: "1,2,3,4",
+ },
+ ],
+ },
+ ]) as Progression.ValidationError;
+
+ expect(error.type).toBe("TOO_MANY_PLACEMENTS");
+ expect((error as any).bracketIdx).toEqual(1);
+ });
+
+ it("accepts A/B divisions placements up to per-division size", () => {
+ const result = getValidatedBrackets([
+ {
+ settings: {
+ hasAbDivisions: true,
+ teamsPerGroup: 6,
+ },
+ type: "round_robin",
+ },
+ {
+ settings: {},
+ type: "single_elimination",
+ sources: [
+ {
+ bracketId: "0",
+ placements: "1,2,3",
+ },
+ ],
+ },
+ ]);
+
+ expect(Array.isArray(result)).toBe(true);
+ });
+
it("handles DUPLICATE_BRACKET_NAME", () => {
const error = getValidatedBrackets([
{
@@ -589,6 +673,165 @@ describe("validatedSources - other rules", () => {
// Should be valid (no error returned)
expect(Array.isArray(result)).toBe(true);
});
+
+ it("accepts A/B divisions on a round robin starting bracket with even teamsPerGroup", () => {
+ const result = getValidatedBrackets([
+ {
+ settings: {
+ hasAbDivisions: true,
+ teamsPerGroup: 6,
+ },
+ type: "round_robin",
+ },
+ {
+ settings: {},
+ type: "single_elimination",
+ sources: [
+ {
+ bracketId: "0",
+ placements: "1-2",
+ },
+ ],
+ },
+ ]);
+
+ expect(Array.isArray(result)).toBe(true);
+ });
+
+ it("handles AB_DIVISIONS_NOT_ROUND_ROBIN", () => {
+ const error = getValidatedBrackets([
+ {
+ settings: {
+ hasAbDivisions: true,
+ },
+ type: "swiss",
+ name: "Swiss",
+ },
+ {
+ settings: {},
+ type: "single_elimination",
+ name: "Finals",
+ sources: [
+ {
+ bracketId: "0",
+ placements: "1-2",
+ },
+ ],
+ },
+ ]) as Progression.ValidationError;
+
+ expect(error.type).toBe("AB_DIVISIONS_NOT_ROUND_ROBIN");
+ expect((error as any).bracketIdx).toEqual(0);
+ });
+
+ it("handles AB_DIVISIONS_NOT_STARTING", () => {
+ const error = getValidatedBrackets([
+ {
+ settings: {},
+ type: "round_robin",
+ name: "Group stage",
+ },
+ {
+ settings: {
+ hasAbDivisions: true,
+ teamsPerGroup: 4,
+ },
+ type: "round_robin",
+ name: "Second RR",
+ sources: [
+ {
+ bracketId: "0",
+ placements: "1-2",
+ },
+ ],
+ },
+ {
+ settings: {},
+ type: "single_elimination",
+ name: "Finals",
+ sources: [
+ {
+ bracketId: "1",
+ placements: "1-2",
+ },
+ ],
+ },
+ ]) as Progression.ValidationError;
+
+ expect(error.type).toBe("AB_DIVISIONS_NOT_STARTING");
+ expect((error as any).bracketIdx).toEqual(1);
+ });
+
+ it("handles AB_DIVISIONS_ODD_TEAMS_PER_GROUP", () => {
+ const error = getValidatedBrackets([
+ {
+ settings: {
+ hasAbDivisions: true,
+ teamsPerGroup: 5,
+ },
+ type: "round_robin",
+ },
+ {
+ settings: {},
+ type: "single_elimination",
+ sources: [
+ {
+ bracketId: "0",
+ placements: "1-2",
+ },
+ ],
+ },
+ ]) as Progression.ValidationError;
+
+ expect(error.type).toBe("AB_DIVISIONS_ODD_TEAMS_PER_GROUP");
+ expect((error as any).bracketIdx).toEqual(0);
+ });
+
+ it("accepts A/B divisions when teamsPerGroup is unset (default is even)", () => {
+ const result = getValidatedBrackets([
+ {
+ settings: {
+ hasAbDivisions: true,
+ },
+ type: "round_robin",
+ },
+ {
+ settings: {},
+ type: "single_elimination",
+ sources: [
+ {
+ bracketId: "0",
+ placements: "1-2",
+ },
+ ],
+ },
+ ]);
+
+ expect(Array.isArray(result)).toBe(true);
+ });
+
+ it("does not apply A/B validation when hasAbDivisions is absent", () => {
+ const result = getValidatedBrackets([
+ {
+ settings: {
+ teamsPerGroup: 5,
+ },
+ type: "round_robin",
+ },
+ {
+ settings: {},
+ type: "single_elimination",
+ sources: [
+ {
+ bracketId: "0",
+ placements: "1-2",
+ },
+ ],
+ },
+ ]);
+
+ expect(Array.isArray(result)).toBe(true);
+ });
});
describe("isFinals", () => {
diff --git a/app/features/tournament-bracket/core/Progression.ts b/app/features/tournament-bracket/core/Progression.ts
index 60117da01..746d21ce1 100644
--- a/app/features/tournament-bracket/core/Progression.ts
+++ b/app/features/tournament-bracket/core/Progression.ts
@@ -97,6 +97,21 @@ export type ValidationError =
| {
type: "SWISS_EARLY_ADVANCE_NO_DESTINATION";
bracketIdx: number;
+ }
+ // A/B divisions setting is only valid on round robin brackets
+ | {
+ type: "AB_DIVISIONS_NOT_ROUND_ROBIN";
+ bracketIdx: number;
+ }
+ // A/B divisions setting is only valid on starting brackets (no sources)
+ | {
+ type: "AB_DIVISIONS_NOT_STARTING";
+ bracketIdx: number;
+ }
+ // A/B divisions requires an even teamsPerGroup so each group can be split equally
+ | {
+ type: "AB_DIVISIONS_ODD_TEAMS_PER_GROUP";
+ bracketIdx: number;
};
/** Takes validated brackets and returns them in the format that is ready for user input. */
@@ -274,6 +289,30 @@ export function bracketsToValidationError(
};
}
+ faultyBracketIdx = abDivisionsOnNonRoundRobin(brackets);
+ if (typeof faultyBracketIdx === "number") {
+ return {
+ type: "AB_DIVISIONS_NOT_ROUND_ROBIN",
+ bracketIdx: faultyBracketIdx,
+ };
+ }
+
+ faultyBracketIdx = abDivisionsOnNonStartingBracket(brackets);
+ if (typeof faultyBracketIdx === "number") {
+ return {
+ type: "AB_DIVISIONS_NOT_STARTING",
+ bracketIdx: faultyBracketIdx,
+ };
+ }
+
+ faultyBracketIdx = abDivisionsOddTeamsPerGroup(brackets);
+ if (typeof faultyBracketIdx === "number") {
+ return {
+ type: "AB_DIVISIONS_ODD_TEAMS_PER_GROUP",
+ bracketIdx: faultyBracketIdx,
+ };
+ }
+
return null;
}
@@ -366,7 +405,6 @@ function resolvesWinner(brackets: ParsedBracket[]) {
const finals = brackets.find((_, idx) => isFinals(idx, brackets));
if (!finals) return false;
- if (finals?.type === "round_robin") return false;
if (
finals.type === "swiss" &&
(finals.settings.groupCount ?? TOURNAMENT.SWISS_DEFAULT_GROUP_COUNT) > 1
@@ -474,9 +512,13 @@ function tooManyPlacements(brackets: ParsedBracket[]) {
for (const source of bracket.sources ?? []) {
if (!roundRobins.includes(source.bracketIdx)) continue;
- const size =
- brackets[source.bracketIdx].settings.teamsPerGroup ??
+ const sourceSettings = brackets[source.bracketIdx].settings;
+ const teamsPerGroup =
+ sourceSettings.teamsPerGroup ??
TOURNAMENT.RR_DEFAULT_TEAM_COUNT_PER_GROUP;
+ const size = sourceSettings.hasAbDivisions
+ ? teamsPerGroup / 2
+ : teamsPerGroup;
if (source.placements.some((placement) => placement > size)) {
return bracketIdx;
@@ -546,6 +588,46 @@ function noDoubleEliminationPositive(brackets: ParsedBracket[]) {
return null;
}
+function abDivisionsOnNonRoundRobin(brackets: ParsedBracket[]) {
+ for (const [bracketIdx, bracket] of brackets.entries()) {
+ if (bracket.settings.hasAbDivisions && bracket.type !== "round_robin") {
+ return bracketIdx;
+ }
+ }
+
+ return null;
+}
+
+function abDivisionsOnNonStartingBracket(brackets: ParsedBracket[]) {
+ for (const [bracketIdx, bracket] of brackets.entries()) {
+ if (
+ bracket.settings.hasAbDivisions &&
+ bracket.sources &&
+ bracket.sources.length > 0
+ ) {
+ return bracketIdx;
+ }
+ }
+
+ return null;
+}
+
+function abDivisionsOddTeamsPerGroup(brackets: ParsedBracket[]) {
+ for (const [bracketIdx, bracket] of brackets.entries()) {
+ if (!bracket.settings.hasAbDivisions) continue;
+
+ const teamsPerGroup =
+ bracket.settings.teamsPerGroup ??
+ TOURNAMENT.RR_DEFAULT_TEAM_COUNT_PER_GROUP;
+
+ if (teamsPerGroup % 2 !== 0) {
+ return bracketIdx;
+ }
+ }
+
+ return null;
+}
+
function swissEarlyAdvanceWithoutDestination(brackets: ParsedBracket[]) {
for (const [bracketIdx, bracket] of brackets.entries()) {
if (bracket.type === "swiss" && bracket.settings.advanceThreshold) {
@@ -585,6 +667,16 @@ export function isFinals(idx: number, brackets: ParsedBracket[]) {
return resolveMainBracketProgression(brackets).at(-1) === idx;
}
+/** Returns true if the finals bracket of the tournament is an A/B divisions round robin. */
+export function hasAbDivisionsFinals(brackets: ParsedBracket[]): boolean {
+ const finals = brackets.find((_, idx) => isFinals(idx, brackets));
+ if (!finals) return false;
+
+ return (
+ finals.type === "round_robin" && finals.settings?.hasAbDivisions === true
+ );
+}
+
/** Given bracketIdx and bracketProgression will resolve if this an "underground bracket".
* Underground bracket is defined as a bracket that is not part of the main tournament progression e.g. optional bracket for early losers
*/
diff --git a/app/features/tournament-bracket/core/Tournament.ts b/app/features/tournament-bracket/core/Tournament.ts
index 63e08528f..6b81a5937 100644
--- a/app/features/tournament-bracket/core/Tournament.ts
+++ b/app/features/tournament-bracket/core/Tournament.ts
@@ -556,6 +556,7 @@ export class Tournament {
return {
groupCount: Math.ceil(participantsCount / teamsPerGroup),
seedOrdering: ["groups.seed_optimized"],
+ hasAbDivisions: selectedSettings?.hasAbDivisions ?? false,
};
}
case "swiss": {
@@ -827,6 +828,7 @@ export class Tournament {
/** Can a new sub post be made at this time? */
get canAddNewSubPost() {
if (!this.lfgEnabled) return false;
+ if (this.isInvitational) return false;
if (this.ctx.isFinalized) return false;
return (
diff --git a/app/features/tournament-bracket/core/summarizer.server.ts b/app/features/tournament-bracket/core/summarizer.server.ts
index 9d3cb9c98..c1a1b952e 100644
--- a/app/features/tournament-bracket/core/summarizer.server.ts
+++ b/app/features/tournament-bracket/core/summarizer.server.ts
@@ -18,6 +18,7 @@ import {
} from "../tournament-bracket-utils";
import type { Standing } from "./Bracket";
import type { ParsedBracket } from "./Progression";
+import * as Progression from "./Progression";
export interface TournamentSummary {
skills: Omit<
@@ -41,6 +42,7 @@ type TeamsArg = Array<{
id: number;
members: Array<{ userId: number }>;
startingBracketIdx?: number | null;
+ abDivision?: number | null;
}>;
type Rating = Pick;
@@ -574,25 +576,31 @@ function tournamentResults({
}) {
const result: TournamentSummary["tournamentResults"] = [];
- const firstPlaceFinishesCount = finalStandings.filter(
- (s) => s.placement === 1,
- ).length;
- const isMultiStartingBracket = firstPlaceFinishesCount > 1;
+ const isMultiStartingBracket =
+ Progression.startingBrackets(progression).length > 1;
+ const isAbDivisionsFinals = Progression.hasAbDivisionsFinals(progression);
for (const standing of finalStandings) {
const team = teams.find((t) => t.id === standing.team.id);
invariant(team);
- const div =
- // second check should be redundant, but just here in case
- typeof team.startingBracketIdx === "number" && isMultiStartingBracket
- ? getBracketProgressionLabel(team.startingBracketIdx, progression)
- : null;
- const divisionParticipantCount =
- div !== null
- ? teams.filter((t) => t.startingBracketIdx === team.startingBracketIdx)
- .length
- : participantCount;
+ let div: string | null = null;
+ let divisionParticipantCount = participantCount;
+
+ if (isAbDivisionsFinals && typeof team.abDivision === "number") {
+ div = team.abDivision === 0 ? "A" : "B";
+ divisionParticipantCount = teams.filter(
+ (t) => t.abDivision === team.abDivision,
+ ).length;
+ } else if (
+ isMultiStartingBracket &&
+ typeof team.startingBracketIdx === "number"
+ ) {
+ div = getBracketProgressionLabel(team.startingBracketIdx, progression);
+ divisionParticipantCount = teams.filter(
+ (t) => t.startingBracketIdx === team.startingBracketIdx,
+ ).length;
+ }
for (const player of standing.team.members) {
result.push({
diff --git a/app/features/tournament-bracket/core/summarizer.test.ts b/app/features/tournament-bracket/core/summarizer.test.ts
index 901d06f09..5687b80b0 100644
--- a/app/features/tournament-bracket/core/summarizer.test.ts
+++ b/app/features/tournament-bracket/core/summarizer.test.ts
@@ -3,6 +3,7 @@ import { describe, expect, test } from "vitest";
import invariant from "~/utils/invariant";
import type { Tables } from "../../../db/tables";
import type { AllMatchResult } from "../queries/allMatchResultsByTournamentId.server";
+import type { ParsedBracket } from "./Progression";
import { tournamentSummary } from "./summarizer.server";
import type { TournamentDataTeam } from "./Tournament.server";
@@ -33,6 +34,7 @@ describe("tournamentSummary()", () => {
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
mapPool: [],
members: userIds.map((userId) => ({
country: null,
@@ -64,6 +66,7 @@ describe("tournamentSummary()", () => {
seedingSkillCountsFor,
withMemberInTwoTeams = false,
teamsWithStartingBrackets,
+ teamsWithAbDivisions,
progression,
finalStandings,
}: {
@@ -74,13 +77,11 @@ describe("tournamentSummary()", () => {
id: number;
startingBracketIdx: number | null;
}>;
- progression?: Array<{
- name: string;
- type: "single_elimination";
- settings: Record;
- requiresCheckIn: boolean;
- sources?: Array<{ bracketIdx: number; placements: number[] }>;
+ teamsWithAbDivisions?: Array<{
+ id: number;
+ abDivision: 0 | 1;
}>;
+ progression?: ParsedBracket[];
finalStandings?: Array<{
placement: number;
team: TournamentDataTeam;
@@ -121,17 +122,19 @@ describe("tournamentSummary()", () => {
},
];
- const teams = teamsWithStartingBrackets
- ? defaultTeams.map((team) => {
- const startingBracket = teamsWithStartingBrackets.find(
- (t) => t.id === team.id,
- );
- return {
- ...team,
- startingBracketIdx: startingBracket?.startingBracketIdx ?? null,
- };
- })
- : defaultTeams;
+ const teams = defaultTeams.map((team) => {
+ const startingBracket = teamsWithStartingBrackets?.find(
+ (t) => t.id === team.id,
+ );
+ const abDivisionEntry = teamsWithAbDivisions?.find(
+ (t) => t.id === team.id,
+ );
+ return {
+ ...team,
+ startingBracketIdx: startingBracket?.startingBracketIdx ?? null,
+ abDivision: abDivisionEntry?.abDivision ?? null,
+ };
+ });
return tournamentSummary({
finalStandings: finalStandings ?? [
@@ -778,6 +781,102 @@ describe("tournamentSummary()", () => {
expect(team4Results.every((r) => r.participantCount === 2)).toBeTruthy();
});
+ test("div is set from abDivision when finals is an A/B divisions round robin", () => {
+ const summary = summarize({
+ teamsWithAbDivisions: [
+ { id: 1, abDivision: 0 },
+ { id: 2, abDivision: 1 },
+ { id: 3, abDivision: 0 },
+ { id: 4, abDivision: 1 },
+ ],
+ progression: [
+ {
+ name: "Groups stage",
+ type: "round_robin",
+ settings: { hasAbDivisions: true, teamsPerGroup: 4 },
+ requiresCheckIn: false,
+ },
+ ],
+ finalStandings: [
+ {
+ placement: 1,
+ team: createTeam(1, [1, 2, 3, 4]),
+ },
+ {
+ placement: 1,
+ team: createTeam(2, [5, 6, 7, 8]),
+ },
+ {
+ placement: 2,
+ team: createTeam(3, [9, 10, 11, 12]),
+ },
+ {
+ placement: 2,
+ team: createTeam(4, [13, 14, 15, 16]),
+ },
+ ],
+ });
+
+ const team1Results = summary.tournamentResults.filter(
+ (r) => r.tournamentTeamId === 1,
+ );
+ const team2Results = summary.tournamentResults.filter(
+ (r) => r.tournamentTeamId === 2,
+ );
+ const team3Results = summary.tournamentResults.filter(
+ (r) => r.tournamentTeamId === 3,
+ );
+ const team4Results = summary.tournamentResults.filter(
+ (r) => r.tournamentTeamId === 4,
+ );
+
+ expect(team1Results.every((r) => r.div === "A")).toBeTruthy();
+ expect(team2Results.every((r) => r.div === "B")).toBeTruthy();
+ expect(team3Results.every((r) => r.div === "A")).toBeTruthy();
+ expect(team4Results.every((r) => r.div === "B")).toBeTruthy();
+ });
+
+ test("participantCount counts teams per abDivision for A/B finals", () => {
+ const summary = summarize({
+ teamsWithAbDivisions: [
+ { id: 1, abDivision: 0 },
+ { id: 2, abDivision: 1 },
+ { id: 3, abDivision: 0 },
+ { id: 4, abDivision: 1 },
+ ],
+ progression: [
+ {
+ name: "Groups stage",
+ type: "round_robin",
+ settings: { hasAbDivisions: true, teamsPerGroup: 4 },
+ requiresCheckIn: false,
+ },
+ ],
+ finalStandings: [
+ {
+ placement: 1,
+ team: createTeam(1, [1, 2, 3, 4]),
+ },
+ {
+ placement: 1,
+ team: createTeam(2, [5, 6, 7, 8]),
+ },
+ {
+ placement: 2,
+ team: createTeam(3, [9, 10, 11, 12]),
+ },
+ {
+ placement: 2,
+ team: createTeam(4, [13, 14, 15, 16]),
+ },
+ ],
+ });
+
+ for (const result of summary.tournamentResults) {
+ expect(result.participantCount).toBe(2);
+ }
+ });
+
test("excludes matches ended early by organizer from calculations", () => {
const summary = summarize({
results: [
diff --git a/app/features/tournament-bracket/core/tests/mocks-li.ts b/app/features/tournament-bracket/core/tests/mocks-li.ts
index 83e4b2223..9fbbbbe56 100644
--- a/app/features/tournament-bracket/core/tests/mocks-li.ts
+++ b/app/features/tournament-bracket/core/tests/mocks-li.ts
@@ -7255,6 +7255,7 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
droppedOut: 0,
inviteCode: null,
startingBracketIdx: null,
+ abDivision: null,
createdAt: 1733157607,
activeRosterUserIds: [25875, 21063, 11226, 31597],
pickupAvatarUrl: null,
@@ -7364,6 +7365,7 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
droppedOut: 0,
inviteCode: null,
startingBracketIdx: null,
+ abDivision: null,
createdAt: 1733157629,
activeRosterUserIds: [14837, 27260, 42704, 9379],
pickupAvatarUrl: null,
@@ -7473,6 +7475,7 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
droppedOut: 1,
inviteCode: null,
startingBracketIdx: null,
+ abDivision: null,
createdAt: 1733161494,
activeRosterUserIds: [34424, 31195, 31395, 26103],
pickupAvatarUrl: null,
@@ -7582,6 +7585,7 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
droppedOut: 0,
inviteCode: null,
startingBracketIdx: null,
+ abDivision: null,
createdAt: 1733166918,
activeRosterUserIds: null,
pickupAvatarUrl: null,
@@ -7675,6 +7679,7 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
droppedOut: 0,
inviteCode: null,
startingBracketIdx: null,
+ abDivision: null,
createdAt: 1733166213,
activeRosterUserIds: [32160, 29267, 25591, 36962],
pickupAvatarUrl: null,
@@ -7779,6 +7784,7 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
droppedOut: 1,
inviteCode: null,
startingBracketIdx: null,
+ abDivision: null,
createdAt: 1733189945,
activeRosterUserIds: [12418, 34355, 2319, 7430],
pickupAvatarUrl: null,
@@ -7888,6 +7894,7 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
droppedOut: 0,
inviteCode: null,
startingBracketIdx: null,
+ abDivision: null,
createdAt: 1733244862,
activeRosterUserIds: [29425, 31524, 35674, 26285],
pickupAvatarUrl: null,
@@ -7997,6 +8004,7 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
droppedOut: 0,
inviteCode: null,
startingBracketIdx: null,
+ abDivision: null,
createdAt: 1733282085,
activeRosterUserIds: [26747, 27292, 5708, 6309],
pickupAvatarUrl: null,
@@ -8122,6 +8130,7 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
droppedOut: 0,
inviteCode: null,
startingBracketIdx: null,
+ abDivision: null,
createdAt: 1733291438,
activeRosterUserIds: [24459, 40851, 23974, 43608],
pickupAvatarUrl: null,
@@ -8247,6 +8256,7 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
droppedOut: 1,
inviteCode: null,
startingBracketIdx: null,
+ abDivision: null,
createdAt: 1733439755,
activeRosterUserIds: null,
pickupAvatarUrl: null,
@@ -8340,6 +8350,7 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
droppedOut: 0,
inviteCode: null,
startingBracketIdx: null,
+ abDivision: null,
createdAt: 1733485884,
activeRosterUserIds: [30686, 1961, 30685, 22396],
pickupAvatarUrl: null,
@@ -8465,6 +8476,7 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
droppedOut: 0,
inviteCode: null,
startingBracketIdx: null,
+ abDivision: null,
createdAt: 1733937993,
activeRosterUserIds: [12434, 30263, 5861, 24275],
pickupAvatarUrl: null,
@@ -8590,6 +8602,7 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
droppedOut: 0,
inviteCode: null,
startingBracketIdx: null,
+ abDivision: null,
createdAt: 1733166818,
activeRosterUserIds: [32670, 38046, 42638, 34589],
pickupAvatarUrl: "pickup-logo-Hj-Us_Roj5Ksfv000ceBo-1733166818832.webp",
@@ -8699,6 +8712,7 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
droppedOut: 0,
inviteCode: null,
startingBracketIdx: null,
+ abDivision: null,
createdAt: 1733167616,
activeRosterUserIds: [45102, 26711, 41739, 4533],
pickupAvatarUrl: null,
@@ -8808,6 +8822,7 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
droppedOut: 1,
inviteCode: null,
startingBracketIdx: null,
+ abDivision: null,
createdAt: 1733201503,
activeRosterUserIds: [20807, 31556, 33373, 42703],
pickupAvatarUrl: null,
@@ -8933,6 +8948,7 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
droppedOut: 0,
inviteCode: null,
startingBracketIdx: null,
+ abDivision: null,
createdAt: 1733218069,
activeRosterUserIds: [26509, 7959, 7690, 7958],
pickupAvatarUrl: null,
@@ -9042,6 +9058,7 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
droppedOut: 0,
inviteCode: null,
startingBracketIdx: null,
+ abDivision: null,
createdAt: 1733319202,
activeRosterUserIds: [10714, 21685, 8840, 10028],
pickupAvatarUrl: null,
@@ -9167,6 +9184,7 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
droppedOut: 1,
inviteCode: null,
startingBracketIdx: null,
+ abDivision: null,
createdAt: 1733471556,
activeRosterUserIds: [17532, 30204, 36007, 38896],
pickupAvatarUrl: null,
@@ -9276,6 +9294,7 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
droppedOut: 0,
inviteCode: null,
startingBracketIdx: null,
+ abDivision: null,
createdAt: 1733501938,
activeRosterUserIds: [30495, 43073, 30488, 45295],
pickupAvatarUrl: null,
@@ -9385,6 +9404,7 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
droppedOut: 0,
inviteCode: null,
startingBracketIdx: null,
+ abDivision: null,
createdAt: 1733622364,
activeRosterUserIds: null,
pickupAvatarUrl: null,
@@ -9472,6 +9492,7 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
droppedOut: 0,
inviteCode: null,
startingBracketIdx: null,
+ abDivision: null,
createdAt: 1733635706,
activeRosterUserIds: null,
pickupAvatarUrl: null,
@@ -9565,6 +9586,7 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
droppedOut: 0,
inviteCode: null,
startingBracketIdx: null,
+ abDivision: null,
createdAt: 1733671856,
activeRosterUserIds: null,
pickupAvatarUrl: null,
@@ -9653,6 +9675,7 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
droppedOut: 0,
inviteCode: null,
startingBracketIdx: null,
+ abDivision: null,
createdAt: 1733810204,
activeRosterUserIds: [1959, 17352, 33954, 22403],
pickupAvatarUrl: "pickup-logo-3KZntw8OZ9LkW4XqZRLS9-1733810204048.webp",
@@ -9757,6 +9780,7 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
droppedOut: 0,
inviteCode: null,
startingBracketIdx: null,
+ abDivision: null,
createdAt: 1733889961,
activeRosterUserIds: [6696, 32107, 33402, 30619],
pickupAvatarUrl: null,
@@ -9861,6 +9885,7 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
droppedOut: 0,
inviteCode: null,
startingBracketIdx: null,
+ abDivision: null,
createdAt: 1733892132,
activeRosterUserIds: [21670, 8993, 8395, 3566],
pickupAvatarUrl: null,
@@ -9970,6 +9995,7 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
droppedOut: 0,
inviteCode: null,
startingBracketIdx: null,
+ abDivision: null,
createdAt: 1734035170,
activeRosterUserIds: [24510, 10670, 22577, 31143],
pickupAvatarUrl: null,
@@ -10079,6 +10105,7 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
droppedOut: 0,
inviteCode: null,
startingBracketIdx: null,
+ abDivision: null,
createdAt: 1734107844,
activeRosterUserIds: [28170, 14309, 17310, 23164],
pickupAvatarUrl: null,
@@ -10188,6 +10215,7 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
droppedOut: 0,
inviteCode: null,
startingBracketIdx: null,
+ abDivision: null,
createdAt: 1734132225,
activeRosterUserIds: null,
pickupAvatarUrl: "pickup-logo-_asHjlVchhJ50PH_mDBtw-1734132224819.webp",
@@ -10276,6 +10304,7 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
droppedOut: 0,
inviteCode: null,
startingBracketIdx: null,
+ abDivision: null,
createdAt: 1733194304,
activeRosterUserIds: [40505, 29011, 23082, 45036],
pickupAvatarUrl: null,
@@ -10385,6 +10414,7 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
droppedOut: 0,
inviteCode: null,
startingBracketIdx: null,
+ abDivision: null,
createdAt: 1733195091,
activeRosterUserIds: null,
pickupAvatarUrl: null,
@@ -10478,6 +10508,7 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
droppedOut: 0,
inviteCode: null,
startingBracketIdx: null,
+ abDivision: null,
createdAt: 1733364647,
activeRosterUserIds: [22801, 31150, 35354, 27747],
pickupAvatarUrl: null,
@@ -10587,6 +10618,7 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
droppedOut: 0,
inviteCode: null,
startingBracketIdx: null,
+ abDivision: null,
createdAt: 1733374295,
activeRosterUserIds: null,
pickupAvatarUrl: null,
@@ -10680,6 +10712,7 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
droppedOut: 0,
inviteCode: null,
startingBracketIdx: null,
+ abDivision: null,
createdAt: 1733433864,
activeRosterUserIds: null,
pickupAvatarUrl: null,
@@ -10799,6 +10832,7 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
droppedOut: 0,
inviteCode: null,
startingBracketIdx: null,
+ abDivision: null,
createdAt: 1733513814,
activeRosterUserIds: null,
pickupAvatarUrl: null,
@@ -10892,6 +10926,7 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
droppedOut: 0,
inviteCode: null,
startingBracketIdx: null,
+ abDivision: null,
createdAt: 1733602400,
activeRosterUserIds: [10826, 4248, 20419, 11180],
pickupAvatarUrl: null,
@@ -11001,6 +11036,7 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
droppedOut: 0,
inviteCode: null,
startingBracketIdx: null,
+ abDivision: null,
createdAt: 1733753214,
activeRosterUserIds: [27903, 28446, 34634, 30728],
pickupAvatarUrl: null,
@@ -11110,6 +11146,7 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
droppedOut: 0,
inviteCode: null,
startingBracketIdx: null,
+ abDivision: null,
createdAt: 1733914001,
activeRosterUserIds: [32909, 10190, 35922, 40304],
pickupAvatarUrl: null,
@@ -11235,6 +11272,7 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
droppedOut: 0,
inviteCode: null,
startingBracketIdx: null,
+ abDivision: null,
createdAt: 1733966548,
activeRosterUserIds: [35617, 37669, 37436, 35811],
pickupAvatarUrl: null,
@@ -11344,6 +11382,7 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
droppedOut: 0,
inviteCode: null,
startingBracketIdx: null,
+ abDivision: null,
createdAt: 1734032213,
activeRosterUserIds: null,
pickupAvatarUrl: null,
@@ -11437,6 +11476,7 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
droppedOut: 0,
inviteCode: null,
startingBracketIdx: null,
+ abDivision: null,
createdAt: 1734106606,
activeRosterUserIds: [37173, 43269, 43623, 16054],
pickupAvatarUrl: null,
@@ -11546,6 +11586,7 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
droppedOut: 0,
inviteCode: null,
startingBracketIdx: null,
+ abDivision: null,
createdAt: 1734116765,
activeRosterUserIds: [25312, 10378, 46771, 26044],
pickupAvatarUrl: null,
@@ -11671,6 +11712,7 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
droppedOut: 0,
inviteCode: null,
startingBracketIdx: null,
+ abDivision: null,
createdAt: 1734125312,
activeRosterUserIds: null,
pickupAvatarUrl: null,
@@ -11764,6 +11806,7 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
droppedOut: 0,
inviteCode: null,
startingBracketIdx: null,
+ abDivision: null,
createdAt: 1734134382,
activeRosterUserIds: [26758, 25689, 42164, 44475],
pickupAvatarUrl: null,
@@ -11868,6 +11911,7 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
droppedOut: 0,
inviteCode: null,
startingBracketIdx: null,
+ abDivision: null,
createdAt: 1733156802,
activeRosterUserIds: [9036, 7434, 3738, 9112],
pickupAvatarUrl: null,
@@ -11977,6 +12021,7 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
droppedOut: 0,
inviteCode: null,
startingBracketIdx: null,
+ abDivision: null,
createdAt: 1733157391,
activeRosterUserIds: [5935, 38204, 3741, 8080],
pickupAvatarUrl: null,
@@ -12102,6 +12147,7 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
droppedOut: 0,
inviteCode: null,
startingBracketIdx: null,
+ abDivision: null,
createdAt: 1733162274,
activeRosterUserIds: null,
pickupAvatarUrl: null,
@@ -12195,6 +12241,7 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
droppedOut: 0,
inviteCode: null,
startingBracketIdx: null,
+ abDivision: null,
createdAt: 1733367806,
activeRosterUserIds: null,
pickupAvatarUrl: null,
@@ -12288,6 +12335,7 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
droppedOut: 0,
inviteCode: null,
startingBracketIdx: null,
+ abDivision: null,
createdAt: 1733456080,
activeRosterUserIds: [10386, 33369, 29617, 22942],
pickupAvatarUrl: null,
@@ -12397,6 +12445,7 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
droppedOut: 0,
inviteCode: null,
startingBracketIdx: null,
+ abDivision: null,
createdAt: 1733579092,
activeRosterUserIds: null,
pickupAvatarUrl: null,
@@ -12484,6 +12533,7 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
droppedOut: 0,
inviteCode: null,
startingBracketIdx: null,
+ abDivision: null,
createdAt: 1733769667,
activeRosterUserIds: [3481, 38022, 41269, 43551],
pickupAvatarUrl: null,
@@ -12609,6 +12659,7 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
droppedOut: 0,
inviteCode: null,
startingBracketIdx: null,
+ abDivision: null,
createdAt: 1733794148,
activeRosterUserIds: [22820, 29636, 27036, 28959],
pickupAvatarUrl: null,
@@ -12734,6 +12785,7 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
droppedOut: 1,
inviteCode: null,
startingBracketIdx: null,
+ abDivision: null,
createdAt: 1733820540,
activeRosterUserIds: null,
pickupAvatarUrl: "pickup-logo-t2-mrQNINFqIoFNYuxbmW-1733820600291.webp",
@@ -12822,6 +12874,7 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
droppedOut: 0,
inviteCode: null,
startingBracketIdx: null,
+ abDivision: null,
createdAt: 1733825084,
activeRosterUserIds: null,
pickupAvatarUrl: null,
@@ -12915,6 +12968,7 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
droppedOut: 1,
inviteCode: null,
startingBracketIdx: null,
+ abDivision: null,
createdAt: 1733865890,
activeRosterUserIds: [15425, 41975, 28938, 8587],
pickupAvatarUrl: null,
@@ -13024,6 +13078,7 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
droppedOut: 1,
inviteCode: null,
startingBracketIdx: null,
+ abDivision: null,
createdAt: 1733873149,
activeRosterUserIds: [40550, 7115, 29674, 30031],
pickupAvatarUrl: null,
@@ -13149,6 +13204,7 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
droppedOut: 0,
inviteCode: null,
startingBracketIdx: null,
+ abDivision: null,
createdAt: 1733875608,
activeRosterUserIds: null,
pickupAvatarUrl: null,
@@ -13242,6 +13298,7 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
droppedOut: 0,
inviteCode: null,
startingBracketIdx: null,
+ abDivision: null,
createdAt: 1733888417,
activeRosterUserIds: null,
pickupAvatarUrl: "pickup-logo-c9a1igcMT4m2otyRdTs_0-1733888672873.webp",
@@ -13330,6 +13387,7 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
droppedOut: 1,
inviteCode: null,
startingBracketIdx: null,
+ abDivision: null,
createdAt: 1734008857,
activeRosterUserIds: [30266, 37341, 22699, 28145],
pickupAvatarUrl: null,
@@ -13439,6 +13497,7 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
droppedOut: 1,
inviteCode: null,
startingBracketIdx: null,
+ abDivision: null,
createdAt: 1734018352,
activeRosterUserIds: null,
pickupAvatarUrl: null,
@@ -13532,6 +13591,7 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
droppedOut: 0,
inviteCode: null,
startingBracketIdx: null,
+ abDivision: null,
createdAt: 1734019701,
activeRosterUserIds: [35421, 33524, 22500, 32802],
pickupAvatarUrl: "pickup-logo-u4oKxXYjamTXZ1x-bgNFp-1734019701188.webp",
@@ -13652,6 +13712,7 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
droppedOut: 1,
inviteCode: null,
startingBracketIdx: null,
+ abDivision: null,
createdAt: 1734023441,
activeRosterUserIds: [1852, 2898, 25763, 3466],
pickupAvatarUrl: null,
@@ -13761,6 +13822,7 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
droppedOut: 0,
inviteCode: null,
startingBracketIdx: null,
+ abDivision: null,
createdAt: 1734099744,
activeRosterUserIds: [39098, 22624, 28137, 2769],
pickupAvatarUrl: null,
@@ -13870,6 +13932,7 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
droppedOut: 0,
inviteCode: null,
startingBracketIdx: null,
+ abDivision: null,
createdAt: 1734109256,
activeRosterUserIds: [29661, 15158, 35067, 31655],
pickupAvatarUrl: "pickup-logo-An13SrR78qDNIM2t95ujb-1734109256283.webp",
@@ -13990,6 +14053,7 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
droppedOut: 0,
inviteCode: null,
startingBracketIdx: null,
+ abDivision: null,
createdAt: 1734125682,
activeRosterUserIds: [36575, 30425, 32430, 24290],
pickupAvatarUrl: null,
@@ -14115,6 +14179,7 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
droppedOut: 1,
inviteCode: null,
startingBracketIdx: null,
+ abDivision: null,
createdAt: 1733515005,
activeRosterUserIds: null,
pickupAvatarUrl: null,
@@ -14208,6 +14273,7 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
droppedOut: 0,
inviteCode: null,
startingBracketIdx: null,
+ abDivision: null,
createdAt: 1733521735,
activeRosterUserIds: [44772, 38912, 36853, 42599],
pickupAvatarUrl: null,
@@ -14317,6 +14383,7 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
droppedOut: 0,
inviteCode: null,
startingBracketIdx: null,
+ abDivision: null,
createdAt: 1733525617,
activeRosterUserIds: null,
pickupAvatarUrl: null,
@@ -14410,6 +14477,7 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
droppedOut: 0,
inviteCode: null,
startingBracketIdx: null,
+ abDivision: null,
createdAt: 1733847805,
activeRosterUserIds: [33615, 32015, 45778, 32970],
pickupAvatarUrl: null,
@@ -14519,6 +14587,7 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
droppedOut: 0,
inviteCode: null,
startingBracketIdx: null,
+ abDivision: null,
createdAt: 1733858126,
activeRosterUserIds: [34545, 35567, 41108, 41255],
pickupAvatarUrl: null,
@@ -14628,6 +14697,7 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
droppedOut: 0,
inviteCode: null,
startingBracketIdx: null,
+ abDivision: null,
createdAt: 1733966096,
activeRosterUserIds: [39470, 42874, 32878, 25741],
pickupAvatarUrl: null,
@@ -14737,6 +14807,7 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
droppedOut: 0,
inviteCode: null,
startingBracketIdx: null,
+ abDivision: null,
createdAt: 1734021147,
activeRosterUserIds: [45250, 45174, 6976, 10222],
pickupAvatarUrl: "pickup-logo-v3boyVjbFsTyMlQylz4Dn-1734021152539.webp",
@@ -14846,6 +14917,7 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
droppedOut: 0,
inviteCode: null,
startingBracketIdx: null,
+ abDivision: null,
createdAt: 1734040772,
activeRosterUserIds: null,
pickupAvatarUrl: "pickup-logo-Jx6JnhFJQjOnM10s_79ld-1734041234919.webp",
@@ -14939,6 +15011,7 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
droppedOut: 1,
inviteCode: null,
startingBracketIdx: null,
+ abDivision: null,
createdAt: 1734033803,
activeRosterUserIds: [27800, 12235, 30044, 29531],
pickupAvatarUrl: null,
@@ -15048,6 +15121,7 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
droppedOut: 0,
inviteCode: null,
startingBracketIdx: null,
+ abDivision: null,
createdAt: 1734099612,
activeRosterUserIds: [24572, 7058, 37641, 33913],
pickupAvatarUrl: "pickup-logo-RrPQW5kG_K1cvjdU5TKcF-1734099611923.webp",
@@ -15152,6 +15226,7 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
droppedOut: 1,
inviteCode: null,
startingBracketIdx: null,
+ abDivision: null,
createdAt: 1734113463,
activeRosterUserIds: null,
pickupAvatarUrl: null,
@@ -15245,6 +15320,7 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
droppedOut: 0,
inviteCode: null,
startingBracketIdx: null,
+ abDivision: null,
createdAt: 1734118202,
activeRosterUserIds: null,
pickupAvatarUrl: null,
@@ -15332,6 +15408,7 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
droppedOut: 0,
inviteCode: null,
startingBracketIdx: null,
+ abDivision: null,
createdAt: 1734134334,
activeRosterUserIds: [11186, 27611, 25952, 23481],
pickupAvatarUrl: null,
@@ -15441,6 +15518,7 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
droppedOut: 1,
inviteCode: null,
startingBracketIdx: null,
+ abDivision: null,
createdAt: 1733169181,
activeRosterUserIds: null,
pickupAvatarUrl: null,
@@ -15534,6 +15612,7 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
droppedOut: 1,
inviteCode: null,
startingBracketIdx: null,
+ abDivision: null,
createdAt: 1733247691,
activeRosterUserIds: null,
pickupAvatarUrl: "pickup-logo--fZF6IGlzuuHeotc6Z00p-1733762912138.webp",
@@ -15627,6 +15706,7 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
droppedOut: 0,
inviteCode: null,
startingBracketIdx: null,
+ abDivision: null,
createdAt: 1733452618,
activeRosterUserIds: null,
pickupAvatarUrl: null,
@@ -15725,6 +15805,7 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
droppedOut: 0,
inviteCode: null,
startingBracketIdx: null,
+ abDivision: null,
createdAt: 1733481710,
activeRosterUserIds: null,
pickupAvatarUrl: null,
@@ -15828,6 +15909,7 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
droppedOut: 0,
inviteCode: null,
startingBracketIdx: null,
+ abDivision: null,
createdAt: 1733508949,
activeRosterUserIds: null,
pickupAvatarUrl: null,
@@ -15921,6 +16003,7 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
droppedOut: 0,
inviteCode: null,
startingBracketIdx: null,
+ abDivision: null,
createdAt: 1733611261,
activeRosterUserIds: null,
pickupAvatarUrl: null,
@@ -16009,6 +16092,7 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
droppedOut: 0,
inviteCode: null,
startingBracketIdx: null,
+ abDivision: null,
createdAt: 1733841846,
activeRosterUserIds: [41943, 46289, 45290, 46394],
pickupAvatarUrl: null,
@@ -16118,6 +16202,7 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
droppedOut: 1,
inviteCode: null,
startingBracketIdx: null,
+ abDivision: null,
createdAt: 1733878153,
activeRosterUserIds: null,
pickupAvatarUrl: null,
@@ -16211,6 +16296,7 @@ export const LOW_INK_DECEMBER_2024 = (): TournamentData => ({
droppedOut: 1,
inviteCode: null,
startingBracketIdx: null,
+ abDivision: null,
createdAt: 1734135144,
activeRosterUserIds: null,
pickupAvatarUrl: "pickup-logo-obQfxdRnJg0CsbrE6OXdl-1734135144301.webp",
diff --git a/app/features/tournament-bracket/core/tests/mocks-sos.ts b/app/features/tournament-bracket/core/tests/mocks-sos.ts
index 86f95b499..8004c0919 100644
--- a/app/features/tournament-bracket/core/tests/mocks-sos.ts
+++ b/app/features/tournament-bracket/core/tests/mocks-sos.ts
@@ -2498,6 +2498,7 @@ export const SWIM_OR_SINK_167 = (
team: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
},
{
id: 14800,
@@ -2606,6 +2607,7 @@ export const SWIM_OR_SINK_167 = (
team: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
},
{
id: 14743,
@@ -2730,6 +2732,7 @@ export const SWIM_OR_SINK_167 = (
team: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
},
{
id: 14801,
@@ -2838,6 +2841,7 @@ export const SWIM_OR_SINK_167 = (
team: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
},
{
id: 14792,
@@ -2946,6 +2950,7 @@ export const SWIM_OR_SINK_167 = (
team: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
},
{
id: 14670,
@@ -3091,6 +3096,7 @@ export const SWIM_OR_SINK_167 = (
},
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
},
{
id: 14661,
@@ -3220,6 +3226,7 @@ export const SWIM_OR_SINK_167 = (
},
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
},
{
id: 14804,
@@ -3349,6 +3356,7 @@ export const SWIM_OR_SINK_167 = (
},
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
},
{
id: 14732,
@@ -3462,6 +3470,7 @@ export const SWIM_OR_SINK_167 = (
},
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
},
{
id: 14747,
@@ -3586,6 +3595,7 @@ export const SWIM_OR_SINK_167 = (
},
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
},
{
id: 14748,
@@ -3710,6 +3720,7 @@ export const SWIM_OR_SINK_167 = (
team: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
},
{
id: 14803,
@@ -3818,6 +3829,7 @@ export const SWIM_OR_SINK_167 = (
team: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
},
{
id: 14795,
@@ -3947,6 +3959,7 @@ export const SWIM_OR_SINK_167 = (
},
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
},
{
id: 14445,
@@ -4092,6 +4105,7 @@ export const SWIM_OR_SINK_167 = (
},
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
},
{
id: 14810,
@@ -4158,6 +4172,7 @@ export const SWIM_OR_SINK_167 = (
team: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
},
{
id: 14777,
@@ -4266,6 +4281,7 @@ export const SWIM_OR_SINK_167 = (
team: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
},
{
id: 14805,
@@ -4374,6 +4390,7 @@ export const SWIM_OR_SINK_167 = (
team: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
},
{
id: 14806,
@@ -4482,6 +4499,7 @@ export const SWIM_OR_SINK_167 = (
team: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
},
{
id: 14653,
@@ -4627,6 +4645,7 @@ export const SWIM_OR_SINK_167 = (
},
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
},
{
id: 14708,
@@ -4756,6 +4775,7 @@ export const SWIM_OR_SINK_167 = (
},
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
},
{
id: 14715,
@@ -4869,6 +4889,7 @@ export const SWIM_OR_SINK_167 = (
},
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
},
{
id: 14796,
@@ -4977,6 +4998,7 @@ export const SWIM_OR_SINK_167 = (
team: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
},
{
id: 14797,
@@ -5085,6 +5107,7 @@ export const SWIM_OR_SINK_167 = (
team: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
},
{
id: 14750,
@@ -5188,6 +5211,7 @@ export const SWIM_OR_SINK_167 = (
},
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
},
{
id: 14809,
@@ -5317,6 +5341,7 @@ export const SWIM_OR_SINK_167 = (
},
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
},
{
id: 14709,
@@ -5430,6 +5455,7 @@ export const SWIM_OR_SINK_167 = (
},
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
},
{
id: 14783,
@@ -5485,6 +5511,7 @@ export const SWIM_OR_SINK_167 = (
},
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
},
{
id: 14702,
@@ -5593,6 +5620,7 @@ export const SWIM_OR_SINK_167 = (
team: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
},
{
id: 14735,
@@ -5722,6 +5750,7 @@ export const SWIM_OR_SINK_167 = (
},
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
},
{
id: 14798,
@@ -5846,6 +5875,7 @@ export const SWIM_OR_SINK_167 = (
team: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
},
{
id: 14663,
@@ -5959,6 +5989,7 @@ export const SWIM_OR_SINK_167 = (
},
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
},
{
id: 14517,
@@ -6088,6 +6119,7 @@ export const SWIM_OR_SINK_167 = (
},
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
},
{
id: 14741,
@@ -6217,6 +6249,7 @@ export const SWIM_OR_SINK_167 = (
},
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
},
{
id: 14711,
@@ -6320,6 +6353,7 @@ export const SWIM_OR_SINK_167 = (
},
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
},
{
id: 14655,
@@ -6465,6 +6499,7 @@ export const SWIM_OR_SINK_167 = (
},
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
},
{
id: 14634,
@@ -6552,6 +6587,7 @@ export const SWIM_OR_SINK_167 = (
},
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
},
{
id: 14799,
@@ -6665,6 +6701,7 @@ export const SWIM_OR_SINK_167 = (
},
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
},
{
id: 14784,
@@ -6747,6 +6784,7 @@ export const SWIM_OR_SINK_167 = (
team: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
},
{
id: 14733,
@@ -6855,6 +6893,7 @@ export const SWIM_OR_SINK_167 = (
team: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
},
{
id: 14611,
@@ -6958,6 +6997,7 @@ export const SWIM_OR_SINK_167 = (
},
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
},
{
id: 14713,
@@ -7082,6 +7122,7 @@ export const SWIM_OR_SINK_167 = (
team: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
},
{
id: 14687,
@@ -7211,6 +7252,7 @@ export const SWIM_OR_SINK_167 = (
},
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
},
{
id: 14742,
@@ -7356,6 +7398,7 @@ export const SWIM_OR_SINK_167 = (
},
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
},
{
id: 14764,
@@ -7464,6 +7507,7 @@ export const SWIM_OR_SINK_167 = (
team: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
},
{
id: 14802,
@@ -7588,6 +7632,7 @@ export const SWIM_OR_SINK_167 = (
team: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
},
{
id: 14696,
@@ -7717,6 +7762,7 @@ export const SWIM_OR_SINK_167 = (
},
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
},
{
id: 14808,
@@ -7825,6 +7871,7 @@ export const SWIM_OR_SINK_167 = (
team: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
},
{
id: 14620,
@@ -7965,6 +8012,7 @@ export const SWIM_OR_SINK_167 = (
team: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
},
{
id: 14737,
@@ -8094,6 +8142,7 @@ export const SWIM_OR_SINK_167 = (
},
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
},
{
id: 14503,
@@ -8181,6 +8230,7 @@ export const SWIM_OR_SINK_167 = (
},
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
},
{
id: 14739,
@@ -8289,6 +8339,7 @@ export const SWIM_OR_SINK_167 = (
team: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
},
{
id: 14607,
@@ -8402,6 +8453,7 @@ export const SWIM_OR_SINK_167 = (
},
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
},
],
tieBreakerMapPool: [],
diff --git a/app/features/tournament-bracket/core/tests/mocks-zones-weekly.ts b/app/features/tournament-bracket/core/tests/mocks-zones-weekly.ts
index d714c0302..a9718d5e4 100644
--- a/app/features/tournament-bracket/core/tests/mocks-zones-weekly.ts
+++ b/app/features/tournament-bracket/core/tests/mocks-zones-weekly.ts
@@ -389,6 +389,7 @@ export const ZONES_WEEKLY_38 = (): TournamentData => ({
createdAt: 1734656039,
activeRosterUserIds: [5662, 2899, 6114, 30176],
startingBracketIdx: null,
+ abDivision: null,
pickupAvatarUrl: null,
members: [
{
@@ -498,6 +499,7 @@ export const ZONES_WEEKLY_38 = (): TournamentData => ({
createdAt: 1734423187,
activeRosterUserIds: null,
startingBracketIdx: null,
+ abDivision: null,
pickupAvatarUrl: "pickup-logo-rZYQMu8ELjiFkeiAVGJUt-1734424882431.webp",
members: [
{
@@ -586,6 +588,7 @@ export const ZONES_WEEKLY_38 = (): TournamentData => ({
createdAt: 1734660846,
activeRosterUserIds: null,
startingBracketIdx: null,
+ abDivision: null,
pickupAvatarUrl: null,
members: [
{
@@ -674,6 +677,7 @@ export const ZONES_WEEKLY_38 = (): TournamentData => ({
createdAt: 1734683349,
activeRosterUserIds: [37632, 13590, 10757, 33047],
startingBracketIdx: null,
+ abDivision: null,
pickupAvatarUrl: null,
members: [
{
@@ -783,6 +787,7 @@ export const ZONES_WEEKLY_38 = (): TournamentData => ({
createdAt: 1734608907,
activeRosterUserIds: [11780, 46006, 43518, 33483],
startingBracketIdx: null,
+ abDivision: null,
pickupAvatarUrl: "pickup-logo-FOfFcEbo2OJxIJIJxNJqu-1734608907317.webp",
members: [
{
@@ -903,6 +908,7 @@ export const ZONES_WEEKLY_38 = (): TournamentData => ({
createdAt: 1734397954,
activeRosterUserIds: [46467, 46813, 33491, 43662],
startingBracketIdx: null,
+ abDivision: null,
pickupAvatarUrl: "pickup-logo-y79k_HOVmjv4KfhTjuSqh-1734398099266.webp",
members: [
{
@@ -1012,6 +1018,7 @@ export const ZONES_WEEKLY_38 = (): TournamentData => ({
createdAt: 1734598652,
activeRosterUserIds: null,
startingBracketIdx: null,
+ abDivision: null,
pickupAvatarUrl: "pickup-logo-IGXFtjFMa_dxQqAe2dqIR-1734598652684.webp",
members: [
{
diff --git a/app/features/tournament-bracket/core/tests/mocks.ts b/app/features/tournament-bracket/core/tests/mocks.ts
index 6b405608a..eacb0cad1 100644
--- a/app/features/tournament-bracket/core/tests/mocks.ts
+++ b/app/features/tournament-bracket/core/tests/mocks.ts
@@ -1527,6 +1527,7 @@ export const PADDLING_POOL_257 = () =>
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
activeRosterUserIds: [],
pickupAvatarUrl: null,
createdAt: 1709743534,
@@ -1653,6 +1654,7 @@ export const PADDLING_POOL_257 = () =>
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
activeRosterUserIds: [],
pickupAvatarUrl: null,
createdAt: 1709737918,
@@ -1795,6 +1797,7 @@ export const PADDLING_POOL_257 = () =>
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
activeRosterUserIds: [],
pickupAvatarUrl: null,
createdAt: 1709743523,
@@ -1921,6 +1924,7 @@ export const PADDLING_POOL_257 = () =>
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
activeRosterUserIds: [],
pickupAvatarUrl: null,
createdAt: 1709743262,
@@ -2047,6 +2051,7 @@ export const PADDLING_POOL_257 = () =>
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
activeRosterUserIds: [],
pickupAvatarUrl: null,
createdAt: 1709741396,
@@ -2189,6 +2194,7 @@ export const PADDLING_POOL_257 = () =>
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
activeRosterUserIds: [],
pickupAvatarUrl: null,
createdAt: 1709711811,
@@ -2331,6 +2337,7 @@ export const PADDLING_POOL_257 = () =>
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
activeRosterUserIds: [],
pickupAvatarUrl: null,
createdAt: 1709738831,
@@ -2473,6 +2480,7 @@ export const PADDLING_POOL_257 = () =>
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
activeRosterUserIds: [],
pickupAvatarUrl: null,
createdAt: 1709737837,
@@ -2599,6 +2607,7 @@ export const PADDLING_POOL_257 = () =>
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
activeRosterUserIds: [],
pickupAvatarUrl: null,
createdAt: 1709741719,
@@ -2757,6 +2766,7 @@ export const PADDLING_POOL_257 = () =>
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
activeRosterUserIds: [],
pickupAvatarUrl: null,
createdAt: 1709730354,
@@ -2899,6 +2909,7 @@ export const PADDLING_POOL_257 = () =>
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
activeRosterUserIds: [],
pickupAvatarUrl: null,
createdAt: 1709745630,
@@ -3039,6 +3050,7 @@ export const PADDLING_POOL_257 = () =>
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
activeRosterUserIds: [],
pickupAvatarUrl: null,
createdAt: 1709592381,
@@ -3197,6 +3209,7 @@ export const PADDLING_POOL_257 = () =>
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
activeRosterUserIds: [],
pickupAvatarUrl: null,
createdAt: 1709723749,
@@ -3339,6 +3352,7 @@ export const PADDLING_POOL_257 = () =>
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
activeRosterUserIds: [],
pickupAvatarUrl: null,
createdAt: 1709668399,
@@ -3497,6 +3511,7 @@ export const PADDLING_POOL_257 = () =>
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
activeRosterUserIds: [],
pickupAvatarUrl: null,
createdAt: 1709735267,
@@ -3628,6 +3643,7 @@ export const PADDLING_POOL_257 = () =>
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
activeRosterUserIds: [],
pickupAvatarUrl: null,
createdAt: 1709745849,
@@ -3759,6 +3775,7 @@ export const PADDLING_POOL_257 = () =>
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
activeRosterUserIds: [],
pickupAvatarUrl: null,
createdAt: 1709742258,
@@ -3899,6 +3916,7 @@ export const PADDLING_POOL_257 = () =>
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
activeRosterUserIds: [],
pickupAvatarUrl: null,
createdAt: 1709738744,
@@ -4041,6 +4059,7 @@ export const PADDLING_POOL_257 = () =>
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
activeRosterUserIds: [],
pickupAvatarUrl: null,
createdAt: 1709746054,
@@ -4170,6 +4189,7 @@ export const PADDLING_POOL_257 = () =>
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
activeRosterUserIds: [],
pickupAvatarUrl: null,
createdAt: 1709744894,
@@ -4296,6 +4316,7 @@ export const PADDLING_POOL_257 = () =>
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
activeRosterUserIds: [],
pickupAvatarUrl: null,
createdAt: 1709728278,
@@ -4422,6 +4443,7 @@ export const PADDLING_POOL_257 = () =>
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
activeRosterUserIds: [],
pickupAvatarUrl: null,
createdAt: 1709715006,
@@ -4548,6 +4570,7 @@ export const PADDLING_POOL_257 = () =>
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
activeRosterUserIds: [],
pickupAvatarUrl: null,
createdAt: 1709660578,
@@ -4679,6 +4702,7 @@ export const PADDLING_POOL_257 = () =>
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
activeRosterUserIds: [],
pickupAvatarUrl: null,
createdAt: 1709721869,
@@ -4824,6 +4848,7 @@ export const PADDLING_POOL_257 = () =>
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
activeRosterUserIds: [],
pickupAvatarUrl: null,
createdAt: 1709743633,
@@ -4955,6 +4980,7 @@ export const PADDLING_POOL_257 = () =>
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
activeRosterUserIds: [],
pickupAvatarUrl: null,
createdAt: 1709738747,
@@ -5102,6 +5128,7 @@ export const PADDLING_POOL_257 = () =>
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
activeRosterUserIds: [],
pickupAvatarUrl: null,
createdAt: 1709626047,
@@ -5244,6 +5271,7 @@ export const PADDLING_POOL_257 = () =>
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
activeRosterUserIds: [],
pickupAvatarUrl: null,
createdAt: 1709727951,
@@ -5370,6 +5398,7 @@ export const PADDLING_POOL_257 = () =>
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
activeRosterUserIds: [],
pickupAvatarUrl: null,
createdAt: 1709741482,
@@ -5526,6 +5555,7 @@ export const PADDLING_POOL_257 = () =>
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
activeRosterUserIds: [],
pickupAvatarUrl: null,
createdAt: 1709744451,
@@ -5657,6 +5687,7 @@ export const PADDLING_POOL_257 = () =>
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
activeRosterUserIds: [],
pickupAvatarUrl: null,
createdAt: 1709726536,
@@ -5783,6 +5814,7 @@ export const PADDLING_POOL_257 = () =>
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
activeRosterUserIds: [],
pickupAvatarUrl: null,
createdAt: 1709558706,
@@ -5914,6 +5946,7 @@ export const PADDLING_POOL_257 = () =>
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
activeRosterUserIds: [],
pickupAvatarUrl: null,
createdAt: 1709744323,
@@ -6061,6 +6094,7 @@ export const PADDLING_POOL_257 = () =>
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
activeRosterUserIds: [],
pickupAvatarUrl: null,
createdAt: 1709677397,
@@ -6187,6 +6221,7 @@ export const PADDLING_POOL_257 = () =>
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
activeRosterUserIds: [],
pickupAvatarUrl: null,
createdAt: 1709618711,
@@ -8118,6 +8153,7 @@ export const PADDLING_POOL_255 = () =>
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
activeRosterUserIds: [],
pickupAvatarUrl: null,
createdAt: 1708476597,
@@ -8244,6 +8280,7 @@ export const PADDLING_POOL_255 = () =>
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
activeRosterUserIds: [],
pickupAvatarUrl: null,
createdAt: 1708535137,
@@ -8370,6 +8407,7 @@ export const PADDLING_POOL_255 = () =>
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
activeRosterUserIds: [],
pickupAvatarUrl: null,
createdAt: 1708533764,
@@ -8510,6 +8548,7 @@ export const PADDLING_POOL_255 = () =>
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
activeRosterUserIds: [],
pickupAvatarUrl: null,
createdAt: 1708537512,
@@ -8652,6 +8691,7 @@ export const PADDLING_POOL_255 = () =>
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
activeRosterUserIds: [],
pickupAvatarUrl: null,
createdAt: 1708533309,
@@ -8778,6 +8818,7 @@ export const PADDLING_POOL_255 = () =>
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
activeRosterUserIds: [],
pickupAvatarUrl: null,
createdAt: 1708430641,
@@ -8920,6 +8961,7 @@ export const PADDLING_POOL_255 = () =>
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
activeRosterUserIds: [],
pickupAvatarUrl: null,
createdAt: 1708536306,
@@ -9044,6 +9086,7 @@ export const PADDLING_POOL_255 = () =>
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
activeRosterUserIds: [],
pickupAvatarUrl: null,
createdAt: 1708526368,
@@ -9170,6 +9213,7 @@ export const PADDLING_POOL_255 = () =>
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
activeRosterUserIds: [],
pickupAvatarUrl: null,
createdAt: 1708506060,
@@ -9328,6 +9372,7 @@ export const PADDLING_POOL_255 = () =>
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
activeRosterUserIds: [],
pickupAvatarUrl: null,
createdAt: 1708526814,
@@ -9452,6 +9497,7 @@ export const PADDLING_POOL_255 = () =>
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
activeRosterUserIds: [],
pickupAvatarUrl: null,
createdAt: 1708466421,
@@ -9594,6 +9640,7 @@ export const PADDLING_POOL_255 = () =>
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
activeRosterUserIds: [],
pickupAvatarUrl: null,
createdAt: 1708377426,
@@ -9734,6 +9781,7 @@ export const PADDLING_POOL_255 = () =>
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
activeRosterUserIds: [],
pickupAvatarUrl: null,
createdAt: 1708448289,
@@ -9892,6 +9940,7 @@ export const PADDLING_POOL_255 = () =>
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
activeRosterUserIds: [],
pickupAvatarUrl: null,
createdAt: 1708532602,
@@ -10018,6 +10067,7 @@ export const PADDLING_POOL_255 = () =>
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
activeRosterUserIds: [],
pickupAvatarUrl: null,
createdAt: 1708535205,
@@ -10160,6 +10210,7 @@ export const PADDLING_POOL_255 = () =>
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
activeRosterUserIds: [],
pickupAvatarUrl: null,
createdAt: 1708515945,
@@ -10286,6 +10337,7 @@ export const PADDLING_POOL_255 = () =>
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
activeRosterUserIds: [],
pickupAvatarUrl: null,
createdAt: 1708453334,
@@ -10410,6 +10462,7 @@ export const PADDLING_POOL_255 = () =>
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
activeRosterUserIds: [],
pickupAvatarUrl: null,
createdAt: 1708522730,
@@ -10552,6 +10605,7 @@ export const PADDLING_POOL_255 = () =>
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
activeRosterUserIds: [],
pickupAvatarUrl: null,
createdAt: 1708375443,
@@ -10694,6 +10748,7 @@ export const PADDLING_POOL_255 = () =>
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
activeRosterUserIds: [],
pickupAvatarUrl: null,
createdAt: 1708532665,
@@ -10825,6 +10880,7 @@ export const PADDLING_POOL_255 = () =>
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
activeRosterUserIds: [],
pickupAvatarUrl: null,
createdAt: 1708364254,
@@ -10972,6 +11028,7 @@ export const PADDLING_POOL_255 = () =>
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
activeRosterUserIds: [],
pickupAvatarUrl: null,
createdAt: 1708464101,
@@ -11117,6 +11174,7 @@ export const PADDLING_POOL_255 = () =>
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
activeRosterUserIds: [],
pickupAvatarUrl: null,
createdAt: 1708520249,
@@ -11259,6 +11317,7 @@ export const PADDLING_POOL_255 = () =>
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
activeRosterUserIds: [],
pickupAvatarUrl: null,
createdAt: 1708535804,
@@ -11385,6 +11444,7 @@ export const PADDLING_POOL_255 = () =>
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
activeRosterUserIds: [],
pickupAvatarUrl: null,
createdAt: 1708535891,
@@ -11527,6 +11587,7 @@ export const PADDLING_POOL_255 = () =>
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
activeRosterUserIds: [],
pickupAvatarUrl: null,
createdAt: 1708521749,
@@ -11669,6 +11730,7 @@ export const PADDLING_POOL_255 = () =>
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
activeRosterUserIds: [],
pickupAvatarUrl: null,
createdAt: 1708536584,
@@ -11795,6 +11857,7 @@ export const PADDLING_POOL_255 = () =>
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
activeRosterUserIds: [],
pickupAvatarUrl: null,
createdAt: 1708537772,
@@ -11958,6 +12021,7 @@ export const PADDLING_POOL_255 = () =>
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
activeRosterUserIds: [],
pickupAvatarUrl: null,
createdAt: 1708379916,
@@ -12100,6 +12164,7 @@ export const PADDLING_POOL_255 = () =>
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
activeRosterUserIds: [],
pickupAvatarUrl: null,
createdAt: 1708519753,
@@ -12247,6 +12312,7 @@ export const PADDLING_POOL_255 = () =>
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
activeRosterUserIds: [],
pickupAvatarUrl: null,
createdAt: 1708534312,
@@ -12392,6 +12458,7 @@ export const PADDLING_POOL_255 = () =>
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
activeRosterUserIds: [],
pickupAvatarUrl: null,
createdAt: 1708531929,
@@ -12518,6 +12585,7 @@ export const PADDLING_POOL_255 = () =>
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
activeRosterUserIds: [],
pickupAvatarUrl: null,
createdAt: 1708477155,
@@ -12649,6 +12717,7 @@ export const PADDLING_POOL_255 = () =>
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
activeRosterUserIds: [],
pickupAvatarUrl: null,
createdAt: 1708531564,
@@ -12828,6 +12897,7 @@ export const PADDLING_POOL_255 = () =>
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
activeRosterUserIds: [],
pickupAvatarUrl: null,
createdAt: 1708503356,
@@ -15021,6 +15091,7 @@ export const IN_THE_ZONE_32 = ({
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
activeRosterUserIds: [],
pickupAvatarUrl: null,
createdAt: 1707443313,
@@ -15134,6 +15205,7 @@ export const IN_THE_ZONE_32 = ({
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
activeRosterUserIds: [],
pickupAvatarUrl: null,
createdAt: 1707366405,
@@ -15247,6 +15319,7 @@ export const IN_THE_ZONE_32 = ({
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
activeRosterUserIds: [],
pickupAvatarUrl: null,
createdAt: 1706912643,
@@ -15360,6 +15433,7 @@ export const IN_THE_ZONE_32 = ({
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
activeRosterUserIds: [],
pickupAvatarUrl: null,
createdAt: 1707359335,
@@ -15505,6 +15579,7 @@ export const IN_THE_ZONE_32 = ({
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
activeRosterUserIds: [],
pickupAvatarUrl: null,
createdAt: 1707171426,
@@ -15634,6 +15709,7 @@ export const IN_THE_ZONE_32 = ({
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
activeRosterUserIds: [],
pickupAvatarUrl: null,
createdAt: 1707342696,
@@ -15763,6 +15839,7 @@ export const IN_THE_ZONE_32 = ({
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
activeRosterUserIds: [],
pickupAvatarUrl: null,
createdAt: 1707513942,
@@ -15908,6 +15985,7 @@ export const IN_THE_ZONE_32 = ({
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
activeRosterUserIds: [],
pickupAvatarUrl: null,
createdAt: 1707526815,
@@ -16053,6 +16131,7 @@ export const IN_THE_ZONE_32 = ({
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
activeRosterUserIds: [],
pickupAvatarUrl: null,
createdAt: 1707583385,
@@ -16166,6 +16245,7 @@ export const IN_THE_ZONE_32 = ({
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
activeRosterUserIds: [],
pickupAvatarUrl: null,
createdAt: 1707486395,
@@ -16279,6 +16359,7 @@ export const IN_THE_ZONE_32 = ({
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
activeRosterUserIds: [],
pickupAvatarUrl: null,
createdAt: 1707513290,
@@ -16392,6 +16473,7 @@ export const IN_THE_ZONE_32 = ({
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
activeRosterUserIds: [],
pickupAvatarUrl: null,
createdAt: 1707531084,
@@ -16505,6 +16587,7 @@ export const IN_THE_ZONE_32 = ({
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
activeRosterUserIds: [],
pickupAvatarUrl: null,
createdAt: 1707568466,
@@ -16634,6 +16717,7 @@ export const IN_THE_ZONE_32 = ({
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
activeRosterUserIds: [],
pickupAvatarUrl: null,
createdAt: 1707481625,
@@ -16747,6 +16831,7 @@ export const IN_THE_ZONE_32 = ({
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
activeRosterUserIds: [],
pickupAvatarUrl: null,
createdAt: 1707530166,
@@ -16860,6 +16945,7 @@ export const IN_THE_ZONE_32 = ({
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
activeRosterUserIds: [],
pickupAvatarUrl: null,
createdAt: 1707181792,
@@ -16989,6 +17075,7 @@ export const IN_THE_ZONE_32 = ({
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
activeRosterUserIds: [],
pickupAvatarUrl: null,
createdAt: 1707550321,
@@ -17123,6 +17210,7 @@ export const IN_THE_ZONE_32 = ({
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
activeRosterUserIds: [],
pickupAvatarUrl: null,
createdAt: 1707575096,
@@ -17252,6 +17340,7 @@ export const IN_THE_ZONE_32 = ({
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
activeRosterUserIds: [],
pickupAvatarUrl: null,
createdAt: 1707569490,
@@ -17397,6 +17486,7 @@ export const IN_THE_ZONE_32 = ({
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
activeRosterUserIds: [],
pickupAvatarUrl: null,
createdAt: 1707537425,
@@ -17510,6 +17600,7 @@ export const IN_THE_ZONE_32 = ({
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
activeRosterUserIds: [],
pickupAvatarUrl: null,
createdAt: 1707564691,
@@ -17660,6 +17751,7 @@ export const IN_THE_ZONE_32 = ({
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
activeRosterUserIds: [],
pickupAvatarUrl: null,
createdAt: 1707145818,
@@ -17783,6 +17875,7 @@ export const IN_THE_ZONE_32 = ({
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
activeRosterUserIds: [],
pickupAvatarUrl: null,
createdAt: 1707558330,
@@ -17896,6 +17989,7 @@ export const IN_THE_ZONE_32 = ({
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
activeRosterUserIds: [],
pickupAvatarUrl: null,
createdAt: 1707586842,
@@ -18009,6 +18103,7 @@ export const IN_THE_ZONE_32 = ({
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
activeRosterUserIds: [],
pickupAvatarUrl: null,
createdAt: 1707583597,
@@ -18154,6 +18249,7 @@ export const IN_THE_ZONE_32 = ({
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
activeRosterUserIds: [],
pickupAvatarUrl: null,
createdAt: 1707429804,
@@ -18283,6 +18379,7 @@ export const IN_THE_ZONE_32 = ({
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
activeRosterUserIds: [],
pickupAvatarUrl: null,
createdAt: 1707539973,
@@ -18417,6 +18514,7 @@ export const IN_THE_ZONE_32 = ({
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
activeRosterUserIds: [],
pickupAvatarUrl: null,
createdAt: 1707507831,
@@ -18546,6 +18644,7 @@ export const IN_THE_ZONE_32 = ({
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
activeRosterUserIds: [],
pickupAvatarUrl: null,
createdAt: 1707586297,
@@ -18673,6 +18772,7 @@ export const IN_THE_ZONE_32 = ({
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
activeRosterUserIds: [],
pickupAvatarUrl: null,
createdAt: 1707583885,
@@ -18818,6 +18918,7 @@ export const IN_THE_ZONE_32 = ({
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
activeRosterUserIds: [],
pickupAvatarUrl: null,
createdAt: 1707578076,
@@ -18950,6 +19051,7 @@ export const IN_THE_ZONE_32 = ({
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
activeRosterUserIds: [],
pickupAvatarUrl: null,
createdAt: 1707582953,
@@ -19063,6 +19165,7 @@ export const IN_THE_ZONE_32 = ({
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
activeRosterUserIds: [],
pickupAvatarUrl: null,
createdAt: 1707575330,
@@ -19199,6 +19302,7 @@ export const IN_THE_ZONE_32 = ({
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
activeRosterUserIds: [],
pickupAvatarUrl: null,
createdAt: 1707527645,
diff --git a/app/features/tournament-bracket/core/tests/test-utils.ts b/app/features/tournament-bracket/core/tests/test-utils.ts
index b06238715..05afc0675 100644
--- a/app/features/tournament-bracket/core/tests/test-utils.ts
+++ b/app/features/tournament-bracket/core/tests/test-utils.ts
@@ -15,6 +15,7 @@ export const tournamentCtxTeam = (
inviteCode: null,
avgSeedingSkillOrdinal: null,
startingBracketIdx: null,
+ abDivision: null,
team: null,
mapPool: [],
members: [],
diff --git a/app/features/tournament-bracket/loaders/to.$id.matches.$mid.server.ts b/app/features/tournament-bracket/loaders/to.$id.matches.$mid.server.ts
index 04eb9c67b..06f8aed54 100644
--- a/app/features/tournament-bracket/loaders/to.$id.matches.$mid.server.ts
+++ b/app/features/tournament-bracket/loaders/to.$id.matches.$mid.server.ts
@@ -15,10 +15,13 @@ import { executeRoll } from "../core/executeRoll.server";
import { mapListFromResults, resolveMapList } from "../core/mapList.server";
import * as PickBan from "../core/PickBan";
import { tournamentFromDBCached } from "../core/Tournament.server";
-import { findMatchById } from "../queries/findMatchById.server";
import { findResultsByMatchId } from "../queries/findResultsByMatchId.server";
+import * as TournamentMatchRepository from "../TournamentMatchRepository.server";
import { matchPageParamsSchema } from "../tournament-bracket-schemas.server";
-import { matchEndedEarly } from "../tournament-bracket-utils";
+import {
+ matchEndedEarly,
+ tournamentTeamToActiveRosterUserIds,
+} from "../tournament-bracket-utils";
export type TournamentMatchLoaderData = typeof loader;
@@ -33,7 +36,9 @@ export const loader = async ({ params }: LoaderFunctionArgs) => {
user: undefined,
});
- const match = notFoundIfFalsy(findMatchById(matchId));
+ const match = notFoundIfFalsy(
+ await TournamentMatchRepository.findMatchById(matchId),
+ );
const isBye = !match.opponentOne || !match.opponentTwo;
if (isBye) {
@@ -142,10 +147,26 @@ export const loader = async ({ params }: LoaderFunctionArgs) => {
if (
match.chatCode &&
!matchIsOver &&
- match.opponentOne &&
- match.opponentTwo
+ match.opponentOne?.id &&
+ match.opponentTwo?.id
) {
- const playerIds = match.players.map((p) => p.id);
+ // only add global chat for active roster (or all if not yet set i.e. first match)
+ // if roster changed mid-set the subs can still see the chat on the match page
+ const teamAlpha = tournament.teamById(match.opponentOne.id)!;
+ const teamAlphaActiveRoster =
+ tournamentTeamToActiveRosterUserIds(
+ teamAlpha,
+ tournament.minMembersPerTeam,
+ ) ?? teamAlpha.members.map((m) => m.userId);
+ const teamBravo = tournament.teamById(match.opponentTwo.id)!;
+ const teamBravoActiveRoster =
+ tournamentTeamToActiveRosterUserIds(
+ teamBravo,
+ tournament.minMembersPerTeam,
+ ) ?? teamBravo.members.map((m) => m.userId);
+
+ const playerIds = [...teamAlphaActiveRoster, ...teamBravoActiveRoster];
+
const matchContext = tournament.matchContextNamesById(matchId);
ChatSystemMessage.setMetadata({
@@ -163,14 +184,15 @@ export const loader = async ({ params }: LoaderFunctionArgs) => {
tournament.isOrganizerOrStreamer(user) ||
match.players.some((p) => p.id === user?.id);
- const isStaff = user?.roles.includes("STAFF") ?? false;
- const chatCodeExpired = tournament.ctx.isFinalized
- ? true
- : !chatAccessible({
- isStaff,
- expiresAfterDays: 90,
- comparedTo: tournament.ctx.startTime,
- });
+ const isSiteStaff = user?.roles.includes("STAFF") ?? false;
+ const isTournamentStaff = tournament.isOrganizer(user);
+ const chatCodeExpired =
+ tournament.ctx.isFinalized && !isSiteStaff && !isTournamentStaff
+ ? true
+ : !chatAccessible({
+ expiresAfterDays: tournament.isLeagueDivision ? 30 : 7,
+ comparedTo: tournament.ctx.startTime,
+ });
const visibleChatCode =
shouldSeeChat && !chatCodeExpired ? match.chatCode : undefined;
diff --git a/app/features/tournament-bracket/queries/findMatchById.server.ts b/app/features/tournament-bracket/queries/findMatchById.server.ts
deleted file mode 100644
index 74bdc5a39..000000000
--- a/app/features/tournament-bracket/queries/findMatchById.server.ts
+++ /dev/null
@@ -1,91 +0,0 @@
-import { sql } from "~/db/sql";
-import type { Tables, TournamentRoundMaps } from "~/db/tables";
-import type { Match } from "~/modules/brackets-model";
-import { parseDBArray } from "~/utils/sql";
-
-const stm = sql.prepare(/* sql */ `
- select
- "TournamentMatch"."id",
- "TournamentMatch"."groupId",
- "TournamentMatch"."opponentOne",
- "TournamentMatch"."opponentTwo",
- "TournamentMatch"."chatCode",
- "TournamentMatch"."startedAt",
- "TournamentMatch"."status",
- "Tournament"."mapPickingStyle",
- "TournamentRound"."id" as "roundId",
- "TournamentRound"."maps" as "roundMaps",
- json_group_array(
- json_object(
- 'id',
- "User"."id",
- 'username',
- "User"."username",
- 'tournamentTeamId',
- "TournamentTeamMember"."tournamentTeamId",
- 'inGameName',
- COALESCE("TournamentTeamMember"."inGameName", "User"."inGameName"),
- 'discordId',
- "User"."discordId",
- 'customUrl',
- "User"."customUrl",
- 'discordAvatar',
- "User"."discordAvatar",
- 'pronouns', json("User"."pronouns")
- )
- ) as "players"
- from "TournamentMatch"
- left join "TournamentStage" on "TournamentStage"."id" = "TournamentMatch"."stageId"
- left join "TournamentRound" on "TournamentRound"."id" = "TournamentMatch"."roundId"
- left join "Tournament" on "Tournament"."id" = "TournamentStage"."tournamentId"
- left join "TournamentTeamMember" on
- "TournamentTeamMember"."tournamentTeamId" = "TournamentMatch"."opponentOne" ->> '$.id'
- or
- "TournamentTeamMember"."tournamentTeamId" = "TournamentMatch"."opponentTwo" ->> '$.id'
- left join "User" on "User"."id" = "TournamentTeamMember"."userId"
- where "TournamentMatch"."id" = @id
- group by "TournamentMatch"."id"
-`);
-
-export type FindMatchById = ReturnType;
-
-export const findMatchById = (id: number) => {
- const row = stm.get({ id }) as
- | ((Pick<
- Tables["TournamentMatch"],
- "id" | "groupId" | "chatCode" | "startedAt" | "status"
- > &
- Pick & { players: string }) & {
- opponentOne: string;
- opponentTwo: string;
- roundId: number;
- roundMaps: string;
- })
- | undefined;
-
- if (!row) return;
-
- const roundMaps = JSON.parse(row.roundMaps) as TournamentRoundMaps;
-
- return {
- ...row,
- bestOf: roundMaps.count,
- roundId: row.roundId,
- roundMaps,
- opponentOne: JSON.parse(row.opponentOne) as Match["opponent1"],
- opponentTwo: JSON.parse(row.opponentTwo) as Match["opponent2"],
- status: row.status,
- players: (
- parseDBArray(row.players) as Array<{
- id: Tables["User"]["id"];
- username: Tables["User"]["username"];
- tournamentTeamId: Tables["TournamentTeamMember"]["tournamentTeamId"];
- inGameName: Tables["User"]["inGameName"];
- discordId: Tables["User"]["discordId"];
- customUrl: Tables["User"]["customUrl"];
- discordAvatar: Tables["User"]["discordAvatar"];
- pronouns: Tables["User"]["pronouns"];
- }>
- ).filter((player) => player.id),
- };
-};
diff --git a/app/features/tournament-bracket/routes/to.$id.brackets.tsx b/app/features/tournament-bracket/routes/to.$id.brackets.tsx
index 81dc1284f..7b21d0b9f 100644
--- a/app/features/tournament-bracket/routes/to.$id.brackets.tsx
+++ b/app/features/tournament-bracket/routes/to.$id.brackets.tsx
@@ -40,8 +40,10 @@ import { Bracket } from "../components/Bracket";
import { useBracketSpoilerCensor } from "../components/Bracket/useBracketSpoilerCensor";
import { BracketMapListDialog } from "../components/BracketMapListDialog";
import { TournamentTeamActions } from "../components/TournamentTeamActions";
+import * as AbDivisions from "../core/AbDivisions";
import type { Bracket as BracketType } from "../core/Bracket";
import * as PreparedMaps from "../core/PreparedMaps";
+import type { Tournament } from "../core/Tournament";
export { action };
@@ -181,10 +183,24 @@ export default function TournamentBracketsPage() {
return null;
}
+ const abDivisionsStartError = getAbDivisionsStartError(bracket, tournament);
+
return (
{bracket.preview &&
+ tournament.isOrganizer(user) &&
+ tournament.regularCheckInHasEnded &&
+ abDivisionsStartError ? (
+
+
+
+ {abDivisionsStartError}
+
+
+
+ ) : null}
+ {bracket.preview &&
bracket.enoughTeams &&
tournament.isOrganizer(user) &&
tournament.regularCheckInStartInThePast ? (
@@ -201,7 +217,11 @@ export default function TournamentBracketsPage() {
tournament.isDraft ? (
) : (
-
+
)
) : null}
@@ -269,12 +289,41 @@ export default function TournamentBracketsPage() {
);
}
+function getAbDivisionsStartError(
+ bracket: BracketType,
+ tournament: Tournament,
+): string | null {
+ if (
+ bracket.type !== "round_robin" ||
+ !bracket.settings?.hasAbDivisions ||
+ !bracket.isStartingBracket ||
+ !bracket.seeding ||
+ bracket.seeding.length === 0
+ ) {
+ return null;
+ }
+
+ const groupCount = new Set(bracket.data.round.map((r) => r.group_id)).size;
+ const abDivisionsBySeedOrder = bracket.seeding.map(
+ (teamId) => tournament.teamById(teamId)?.abDivision,
+ );
+
+ const result = AbDivisions.validate({
+ abDivisionsBySeedOrder,
+ groupCount,
+ });
+
+ return result.isErr() ? result.error : null;
+}
+
function BracketStarter({
bracket,
bracketIdx,
+ isDisabled,
}: {
bracket: BracketType;
bracketIdx: number;
+ isDisabled?: boolean;
}) {
const [dialogOpen, setDialogOpen] = React.useState(false);
const isHydrated = useHydrated();
@@ -297,6 +346,7 @@ function BracketStarter({
size="small"
data-testid="finalize-bracket-button"
onPress={() => setDialogOpen(true)}
+ isDisabled={isDisabled}
>
Start the bracket
diff --git a/app/features/tournament-lfg/TournamentLFGRepository.server.test.ts b/app/features/tournament-lfg/TournamentLFGRepository.server.test.ts
index 1d3fc7331..665ac0e72 100644
--- a/app/features/tournament-lfg/TournamentLFGRepository.server.test.ts
+++ b/app/features/tournament-lfg/TournamentLFGRepository.server.test.ts
@@ -216,6 +216,94 @@ describe("allLikesByTeamId", () => {
});
});
+describe("startLooking", () => {
+ beforeEach(async () => {
+ await dbInsertUsers(3);
+ });
+
+ afterEach(() => {
+ dbReset();
+ });
+
+ const createRegisteredTeam = async (
+ tournamentId: number,
+ memberUserIds: number[],
+ ) => {
+ const team = await db
+ .insertInto("TournamentTeam")
+ .values({
+ tournamentId,
+ name: "Real Team",
+ inviteCode: `inv-${tournamentId}-${memberUserIds.join("-")}`,
+ isLooking: 0,
+ isPlaceholder: 0,
+ })
+ .returning("id")
+ .executeTakeFirstOrThrow();
+
+ for (const [idx, userId] of memberUserIds.entries()) {
+ await db
+ .insertInto("TournamentTeamMember")
+ .values({
+ tournamentTeamId: team.id,
+ userId,
+ role: idx === 0 ? "OWNER" : "REGULAR",
+ })
+ .execute();
+ }
+
+ return team;
+ };
+
+ test("generates chatCode for a 2+ member team", async () => {
+ const tournament = await createTournament();
+ const team = await createRegisteredTeam(tournament.id, [1, 2]);
+
+ const pickup = await TournamentLFGRepository.startLooking(team.id);
+
+ expect(pickup).not.toBeNull();
+ expect(pickup?.chatCode).toMatch(/.+/);
+ expect(pickup?.memberUserIds.sort()).toEqual([1, 2]);
+
+ const row = await db
+ .selectFrom("TournamentTeam")
+ .select("chatCode")
+ .where("id", "=", team.id)
+ .executeTakeFirstOrThrow();
+ expect(row.chatCode).toBe(pickup?.chatCode);
+ });
+
+ test("returns null when team has only 1 member", async () => {
+ const tournament = await createTournament();
+ const team = await createRegisteredTeam(tournament.id, [1]);
+
+ const pickup = await TournamentLFGRepository.startLooking(team.id);
+
+ expect(pickup).toBeNull();
+
+ const row = await db
+ .selectFrom("TournamentTeam")
+ .select("chatCode")
+ .where("id", "=", team.id)
+ .executeTakeFirstOrThrow();
+ expect(row.chatCode).toBeNull();
+ });
+
+ test("reuses existing chatCode if already set", async () => {
+ const tournament = await createTournament();
+ const team = await createRegisteredTeam(tournament.id, [1, 2]);
+ await db
+ .updateTable("TournamentTeam")
+ .set({ chatCode: "existing-code" })
+ .where("id", "=", team.id)
+ .execute();
+
+ const pickup = await TournamentLFGRepository.startLooking(team.id);
+
+ expect(pickup?.chatCode).toBe("existing-code");
+ });
+});
+
describe("mergeTeams", () => {
beforeEach(async () => {
await dbInsertUsers(5);
@@ -298,6 +386,50 @@ describe("mergeTeams", () => {
expect(groups).toHaveLength(0);
});
+ test("survivor gets a chatCode when merged size is 2+", async () => {
+ const tournament = await createTournament();
+ const team1 = await createPlaceholder(tournament.id, 1);
+ const team2 = await createPlaceholder(tournament.id, 2);
+
+ const result = await TournamentLFGRepository.mergeTeams({
+ survivingTeamId: team1.id,
+ otherTeamId: team2.id,
+ maxGroupSize: 4,
+ });
+
+ expect(result.survivor).not.toBeNull();
+ expect(result.survivor?.chatCode).toMatch(/.+/);
+ expect(result.survivor?.memberUserIds.sort()).toEqual([1, 2]);
+ expect(result.removedChatCode).toBeNull();
+
+ const row = await db
+ .selectFrom("TournamentTeam")
+ .select("chatCode")
+ .where("id", "=", team1.id)
+ .executeTakeFirstOrThrow();
+ expect(row.chatCode).toBe(result.survivor?.chatCode);
+ });
+
+ test("returns removedChatCode when other team had a chatCode", async () => {
+ const tournament = await createTournament();
+ const team1 = await createPlaceholder(tournament.id, 1);
+ const team2 = await createPlaceholder(tournament.id, 2);
+
+ await db
+ .updateTable("TournamentTeam")
+ .set({ chatCode: "other-code" })
+ .where("id", "=", team2.id)
+ .execute();
+
+ const result = await TournamentLFGRepository.mergeTeams({
+ survivingTeamId: team1.id,
+ otherTeamId: team2.id,
+ maxGroupSize: 4,
+ });
+
+ expect(result.removedChatCode).toBe("other-code");
+ });
+
test("clears likes on surviving team after merge", async () => {
const tournament = await createTournament();
const team1 = await createPlaceholder(tournament.id, 1);
diff --git a/app/features/tournament-lfg/TournamentLFGRepository.server.ts b/app/features/tournament-lfg/TournamentLFGRepository.server.ts
index 0cadb1776..26fd51415 100644
--- a/app/features/tournament-lfg/TournamentLFGRepository.server.ts
+++ b/app/features/tournament-lfg/TournamentLFGRepository.server.ts
@@ -9,11 +9,15 @@ import { errorIsSqliteForeignKeyConstraintFailure } from "~/utils/sql";
import { randomTeamName } from "~/utils/team-name";
export function startLooking(teamId: number) {
- return db
- .updateTable("TournamentTeam")
- .set({ isLooking: 1 })
- .where("id", "=", teamId)
- .execute();
+ return db.transaction().execute(async (trx) => {
+ await trx
+ .updateTable("TournamentTeam")
+ .set({ isLooking: 1 })
+ .where("id", "=", teamId)
+ .execute();
+
+ return ensurePickupChatCode(teamId, trx);
+ });
}
type CreatePlaceholderTeamArgs = {
@@ -167,6 +171,12 @@ export function mergeTeams({
maxGroupSize: number;
}) {
return db.transaction().execute(async (trx) => {
+ const otherTeam = await trx
+ .selectFrom("TournamentTeam")
+ .select("chatCode")
+ .where("id", "=", otherTeamId)
+ .executeTakeFirst();
+
const otherMembers = await trx
.selectFrom("TournamentTeamMember")
.select(["TournamentTeamMember.userId", "TournamentTeamMember.role"])
@@ -207,6 +217,13 @@ export function mergeTeams({
})
.where("id", "=", survivingTeamId)
.execute();
+
+ const survivor = await ensurePickupChatCode(survivingTeamId, trx);
+
+ return {
+ survivor,
+ removedChatCode: otherTeam?.chatCode ?? null,
+ };
});
}
@@ -409,3 +426,44 @@ async function getMemberCount(
return members.length;
}
+
+export type PickupChatTeam = {
+ chatCode: string;
+ name: string;
+ memberUserIds: number[];
+};
+
+async function ensurePickupChatCode(
+ teamId: number,
+ trx: Transaction
,
+): Promise {
+ const team = await trx
+ .selectFrom("TournamentTeam")
+ .select(["name", "chatCode"])
+ .where("id", "=", teamId)
+ .executeTakeFirstOrThrow();
+
+ const members = await trx
+ .selectFrom("TournamentTeamMember")
+ .select("userId")
+ .where("tournamentTeamId", "=", teamId)
+ .execute();
+
+ if (members.length < 2) return null;
+
+ let chatCode = team.chatCode;
+ if (!chatCode) {
+ chatCode = shortNanoid();
+ await trx
+ .updateTable("TournamentTeam")
+ .set({ chatCode })
+ .where("id", "=", teamId)
+ .execute();
+ }
+
+ return {
+ chatCode,
+ name: team.name,
+ memberUserIds: members.map((m) => m.userId),
+ };
+}
diff --git a/app/features/tournament-lfg/actions/to.$id.looking.server.ts b/app/features/tournament-lfg/actions/to.$id.looking.server.ts
index 5c6b1f9d9..b9b128976 100644
--- a/app/features/tournament-lfg/actions/to.$id.looking.server.ts
+++ b/app/features/tournament-lfg/actions/to.$id.looking.server.ts
@@ -1,5 +1,6 @@
import type { ActionFunctionArgs } from "react-router";
import { requireUser } from "~/features/auth/core/user.server";
+import * as ChatSystemMessage from "~/features/chat/ChatSystemMessage.server";
import { notify } from "~/features/notifications/core/notify.server";
import { requireNotBannedByOrganization } from "~/features/tournament/tournament-utils.server";
import {
@@ -16,6 +17,7 @@ import { idObject } from "~/utils/zod";
import * as TournamentLFGRepository from "../TournamentLFGRepository.server";
import { lookingSchema } from "../tournament-lfg-schemas";
import { survivingTeamId } from "../tournament-lfg-utils";
+import { setPickupChatMetadata } from "../tournament-lfg-utils.server";
export const action = async ({ request, params }: ActionFunctionArgs) => {
const user = requireUser();
@@ -72,7 +74,18 @@ export const action = async ({ request, params }: ActionFunctionArgs) => {
team.members.length < tournament.maxMembersPerTeam,
"Team is already at max capacity",
);
- await TournamentLFGRepository.startLooking(team.id);
+ const pickup = await TournamentLFGRepository.startLooking(team.id);
+ if (pickup) {
+ setPickupChatMetadata({
+ team: pickup,
+ tournament: {
+ id: tournamentId,
+ name: tournament.ctx.name,
+ logoUrl: tournament.ctx.logoUrl,
+ startTime: tournament.ctx.startTime,
+ },
+ });
+ }
} else {
await TournamentLFGRepository.createPlaceholderTeam({
tournamentId,
@@ -181,12 +194,28 @@ export const action = async ({ request, params }: ActionFunctionArgs) => {
user,
});
- await TournamentLFGRepository.mergeTeams({
+ const mergeResult = await TournamentLFGRepository.mergeTeams({
survivingTeamId: surviving,
otherTeamId: otherGroup.id,
maxGroupSize: tournament.maxMembersPerTeam,
});
+ if (mergeResult.removedChatCode) {
+ ChatSystemMessage.removeRoom(mergeResult.removedChatCode);
+ }
+
+ if (mergeResult.survivor) {
+ setPickupChatMetadata({
+ team: mergeResult.survivor,
+ tournament: {
+ id: tournamentId,
+ name: tournament.ctx.name,
+ logoUrl: tournament.ctx.logoUrl,
+ startTime: tournament.ctx.startTime,
+ },
+ });
+ }
+
notify({
userIds: theirGroup.members.map((m) => m.id),
notification: {
diff --git a/app/features/tournament-lfg/loaders/to.$id.looking.server.ts b/app/features/tournament-lfg/loaders/to.$id.looking.server.ts
index 2e8e055e2..cbf51fe81 100644
--- a/app/features/tournament-lfg/loaders/to.$id.looking.server.ts
+++ b/app/features/tournament-lfg/loaders/to.$id.looking.server.ts
@@ -29,6 +29,10 @@ export const loader = async ({ params }: LoaderFunctionArgs) => {
throw new Response(null, { status: 404 });
}
+ if (tournament.isInvitational) {
+ throw new Response(null, { status: 404 });
+ }
+
if (tournament.isLeagueSignup && !tournament.registrationOpen) {
throw new Response(null, { status: 404 });
}
diff --git a/app/features/tournament-lfg/tournament-lfg-utils.server.ts b/app/features/tournament-lfg/tournament-lfg-utils.server.ts
new file mode 100644
index 000000000..902676a02
--- /dev/null
+++ b/app/features/tournament-lfg/tournament-lfg-utils.server.ts
@@ -0,0 +1,34 @@
+import { add } from "date-fns";
+import * as ChatSystemMessage from "~/features/chat/ChatSystemMessage.server";
+import { tournamentSubsPage } from "~/utils/urls";
+
+const PICKUP_CHAT_EXPIRES_AFTER_DAYS = 7;
+
+export function setPickupChatMetadata({
+ team,
+ tournament,
+}: {
+ team: {
+ chatCode: string;
+ name: string;
+ memberUserIds: number[];
+ };
+ tournament: {
+ id: number;
+ name: string;
+ logoUrl: string | null;
+ startTime: Date;
+ };
+}) {
+ return ChatSystemMessage.setMetadata({
+ chatCode: team.chatCode,
+ header: team.name,
+ subtitle: tournament.name,
+ url: tournamentSubsPage(tournament.id),
+ imageUrl: tournament.logoUrl ?? undefined,
+ participantUserIds: team.memberUserIds,
+ expiresAt: add(tournament.startTime, {
+ days: PICKUP_CHAT_EXPIRES_AFTER_DAYS,
+ }),
+ });
+}
diff --git a/app/features/tournament/TournamentRepository.server.ts b/app/features/tournament/TournamentRepository.server.ts
index 979353454..5b76db9cb 100644
--- a/app/features/tournament/TournamentRepository.server.ts
+++ b/app/features/tournament/TournamentRepository.server.ts
@@ -150,6 +150,7 @@ export async function findById(id: number) {
"TournamentTeam.createdAt",
"TournamentTeam.activeRosterUserIds",
"TournamentTeam.startingBracketIdx",
+ "TournamentTeam.abDivision",
concatUserSubmittedImagePrefix(
innerEb.ref("UserSubmittedImage.url"),
).as("pickupAvatarUrl"),
@@ -464,6 +465,7 @@ export function forShowcase() {
"Tournament.id",
"Tournament.settings",
"Tournament.tier",
+ "Tournament.isFinalized",
"CalendarEvent.authorId",
"CalendarEvent.name",
"CalendarEvent.organizationId",
@@ -646,68 +648,6 @@ export async function friendCodesByTournamentId(tournamentId: number) {
);
}
-export function checkIn({
- tournamentTeamId,
- bracketIdx,
-}: {
- tournamentTeamId: number;
- bracketIdx: number | null;
-}) {
- return db.transaction().execute(async (trx) => {
- let query = trx
- .deleteFrom("TournamentTeamCheckIn")
- .where("TournamentTeamCheckIn.tournamentTeamId", "=", tournamentTeamId)
- .where("TournamentTeamCheckIn.isCheckOut", "=", 1);
-
- if (typeof bracketIdx === "number") {
- query = query.where("TournamentTeamCheckIn.bracketIdx", "=", bracketIdx);
- }
-
- await query.execute();
-
- await trx
- .insertInto("TournamentTeamCheckIn")
- .values({
- checkedInAt: dateToDatabaseTimestamp(new Date()),
- tournamentTeamId,
- bracketIdx,
- })
- .execute();
- });
-}
-
-export function checkOut({
- tournamentTeamId,
- bracketIdx,
-}: {
- tournamentTeamId: number;
- bracketIdx: number | null;
-}) {
- return db.transaction().execute(async (trx) => {
- let query = trx
- .deleteFrom("TournamentTeamCheckIn")
- .where("TournamentTeamCheckIn.tournamentTeamId", "=", tournamentTeamId);
-
- if (typeof bracketIdx === "number") {
- query = query.where("TournamentTeamCheckIn.bracketIdx", "=", bracketIdx);
- }
-
- await query.execute();
-
- if (typeof bracketIdx === "number") {
- await trx
- .insertInto("TournamentTeamCheckIn")
- .values({
- checkedInAt: dateToDatabaseTimestamp(new Date()),
- tournamentTeamId,
- bracketIdx,
- isCheckOut: 1,
- })
- .execute();
- }
- });
-}
-
export function updateProgression({
tournamentId,
bracketProgression,
@@ -800,56 +740,6 @@ export function overrideTeamBracketProgression({
.execute();
}
-export function updateTeamName({
- tournamentTeamId,
- name,
-}: {
- tournamentTeamId: number;
- name: string;
-}) {
- return db
- .updateTable("TournamentTeam")
- .set({
- name,
- })
- .where("id", "=", tournamentTeamId)
- .execute();
-}
-
-export function dropTeamOut({
- tournamentTeamId,
- previewBracketIdxs,
-}: {
- tournamentTeamId: number;
- previewBracketIdxs: number[];
-}) {
- return db.transaction().execute(async (trx) => {
- await trx
- .deleteFrom("TournamentTeamCheckIn")
- .where("tournamentTeamId", "=", tournamentTeamId)
- .where("TournamentTeamCheckIn.bracketIdx", "in", previewBracketIdxs)
- .execute();
-
- await trx
- .updateTable("TournamentTeam")
- .set({
- droppedOut: 1,
- })
- .where("id", "=", tournamentTeamId)
- .execute();
- });
-}
-
-export function undoDropTeamOut(tournamentTeamId: number) {
- return db
- .updateTable("TournamentTeam")
- .set({
- droppedOut: 0,
- })
- .where("id", "=", tournamentTeamId)
- .execute();
-}
-
export function addStaff({
tournamentId,
userId,
diff --git a/app/features/tournament/TournamentTeamRepository.server.ts b/app/features/tournament/TournamentTeamRepository.server.ts
index 3ef2f11c5..0661e20e4 100644
--- a/app/features/tournament/TournamentTeamRepository.server.ts
+++ b/app/features/tournament/TournamentTeamRepository.server.ts
@@ -1,12 +1,11 @@
-// TODO: add rest of the functions here that relate more to tournament teams than tournament/bracket
-
import type { Transaction } from "kysely";
import { sql } from "kysely";
import { db } from "~/db/sql";
import type { DB, Tables } from "~/db/tables";
+import type { MapPool } from "~/features/map-list-generator/core/map-pool";
import type { ModeShort, StageId } from "~/modules/in-game-lists/types";
import { flatZip } from "~/utils/arrays";
-import { databaseTimestampNow } from "~/utils/dates";
+import { databaseTimestampNow, dateToDatabaseTimestamp } from "~/utils/dates";
import { shortNanoid } from "~/utils/id";
import invariant from "~/utils/invariant";
@@ -113,13 +112,11 @@ export function create({
avatarFileName,
userId,
tournamentId,
- ownerInGameName,
}: {
team: Pick;
avatarFileName?: string;
userId: number;
tournamentId: number;
- ownerInGameName: string | null;
}) {
return db.transaction().execute(async (trx) => {
const avatarImgId = avatarFileName
@@ -143,13 +140,15 @@ export function create({
.returning("id")
.executeTakeFirstOrThrow();
+ const inGameName = await resolveInGameName(trx, tournamentId, userId);
+
await trx
.insertInto("TournamentTeamMember")
.values({
tournamentTeamId: tournamentTeam.id,
userId,
role: "OWNER",
- inGameName: ownerInGameName,
+ inGameName,
})
.execute();
@@ -157,6 +156,30 @@ export function create({
});
}
+async function resolveInGameName(
+ trx: Transaction,
+ tournamentId: number,
+ userId: number,
+) {
+ const tournament = await trx
+ .selectFrom("Tournament")
+ .select("Tournament.settings")
+ .where("Tournament.id", "=", tournamentId)
+ .executeTakeFirstOrThrow();
+
+ if (!tournament.settings.requireInGameNames) return null;
+
+ const user = await trx
+ .selectFrom("User")
+ .select("User.inGameName")
+ .where("User.id", "=", userId)
+ .executeTakeFirstOrThrow();
+
+ invariant(user.inGameName, "In-game name is required but not set");
+
+ return user.inGameName;
+}
+
export function copyFromAnotherTournament({
tournamentTeamId,
destinationTournamentId,
@@ -357,6 +380,284 @@ export function updateStartingBrackets(
});
}
+export function updateAbDivisions(
+ abDivisions: {
+ tournamentTeamId: number;
+ abDivision: 0 | 1 | null;
+ }[],
+) {
+ const grouped = Object.groupBy(abDivisions, (ab) => String(ab.abDivision));
+
+ return db.transaction().execute(async (trx) => {
+ for (const [abDivisionKey, tournamentTeams = []] of Object.entries(
+ grouped,
+ )) {
+ if (tournamentTeams.length === 0) continue;
+
+ await trx
+ .updateTable("TournamentTeam")
+ .set({
+ abDivision: abDivisionKey === "null" ? null : Number(abDivisionKey),
+ })
+ .where(
+ "TournamentTeam.id",
+ "in",
+ tournamentTeams.map((t) => t.tournamentTeamId),
+ )
+ .execute();
+ }
+ });
+}
+
+/**
+ * Checks in a tournament team. Clears any existing check-out records before inserting the check-in.
+ * When called without `bracketIdx`, checks in for the whole tournament.
+ * When called with `bracketIdx`, checks in for a specific bracket (e.g. after progression).
+ */
+export function checkIn(
+ tournamentTeamId: number,
+ options?: { bracketIdx: number },
+) {
+ const bracketIdx = options?.bracketIdx ?? null;
+
+ return db.transaction().execute(async (trx) => {
+ let query = trx
+ .deleteFrom("TournamentTeamCheckIn")
+ .where("TournamentTeamCheckIn.tournamentTeamId", "=", tournamentTeamId)
+ .where("TournamentTeamCheckIn.isCheckOut", "=", 1);
+
+ if (typeof bracketIdx === "number") {
+ query = query.where("TournamentTeamCheckIn.bracketIdx", "=", bracketIdx);
+ }
+
+ await query.execute();
+
+ await trx
+ .insertInto("TournamentTeamCheckIn")
+ .values({
+ checkedInAt: dateToDatabaseTimestamp(new Date()),
+ tournamentTeamId,
+ bracketIdx,
+ })
+ .execute();
+ });
+}
+
+export function checkOut({
+ tournamentTeamId,
+ bracketIdx,
+}: {
+ tournamentTeamId: number;
+ bracketIdx: number | null;
+}) {
+ return db.transaction().execute(async (trx) => {
+ let query = trx
+ .deleteFrom("TournamentTeamCheckIn")
+ .where("TournamentTeamCheckIn.tournamentTeamId", "=", tournamentTeamId);
+
+ if (typeof bracketIdx === "number") {
+ query = query.where("TournamentTeamCheckIn.bracketIdx", "=", bracketIdx);
+ }
+
+ await query.execute();
+
+ if (typeof bracketIdx === "number") {
+ await trx
+ .insertInto("TournamentTeamCheckIn")
+ .values({
+ checkedInAt: dateToDatabaseTimestamp(new Date()),
+ tournamentTeamId,
+ bracketIdx,
+ isCheckOut: 1,
+ })
+ .execute();
+ }
+ });
+}
+
+export function updateName({
+ tournamentTeamId,
+ name,
+}: {
+ tournamentTeamId: number;
+ name: string;
+}) {
+ return db
+ .updateTable("TournamentTeam")
+ .set({
+ name,
+ })
+ .where("id", "=", tournamentTeamId)
+ .execute();
+}
+
+export function dropOut({
+ tournamentTeamId,
+ previewBracketIdxs,
+}: {
+ tournamentTeamId: number;
+ previewBracketIdxs: number[];
+}) {
+ return db.transaction().execute(async (trx) => {
+ await trx
+ .deleteFrom("TournamentTeamCheckIn")
+ .where("tournamentTeamId", "=", tournamentTeamId)
+ .where("TournamentTeamCheckIn.bracketIdx", "in", previewBracketIdxs)
+ .execute();
+
+ await trx
+ .updateTable("TournamentTeam")
+ .set({
+ droppedOut: 1,
+ })
+ .where("id", "=", tournamentTeamId)
+ .execute();
+ });
+}
+
+export function undoDropOut(tournamentTeamId: number) {
+ return db
+ .updateTable("TournamentTeam")
+ .set({
+ droppedOut: 0,
+ })
+ .where("id", "=", tournamentTeamId)
+ .execute();
+}
+
+export function join({
+ previousTeamId,
+ whatToDoWithPreviousTeam,
+ newTeamId,
+ userId,
+ checkOutTeam = false,
+}: {
+ previousTeamId?: number;
+ whatToDoWithPreviousTeam?: "LEAVE" | "DELETE";
+ newTeamId: number;
+ userId: number;
+ checkOutTeam?: boolean;
+}) {
+ return db.transaction().execute(async (trx) => {
+ if (whatToDoWithPreviousTeam === "DELETE") {
+ await trx
+ .deleteFrom("TournamentTeam")
+ .where("TournamentTeam.id", "=", previousTeamId!)
+ .execute();
+ } else if (whatToDoWithPreviousTeam === "LEAVE") {
+ await trx
+ .deleteFrom("TournamentTeamMember")
+ .where("TournamentTeamMember.tournamentTeamId", "=", previousTeamId!)
+ .where("TournamentTeamMember.userId", "=", userId)
+ .execute();
+ }
+
+ if (checkOutTeam) {
+ invariant(
+ previousTeamId,
+ "previousTeamId is required when checking out team",
+ );
+ await trx
+ .deleteFrom("TournamentTeamCheckIn")
+ .where("TournamentTeamCheckIn.tournamentTeamId", "=", previousTeamId)
+ .execute();
+ }
+
+ const tournamentId = (
+ await trx
+ .selectFrom("TournamentTeam")
+ .select("TournamentTeam.tournamentId")
+ .where("TournamentTeam.id", "=", newTeamId)
+ .executeTakeFirstOrThrow()
+ ).tournamentId;
+
+ const inGameName = await resolveInGameName(trx, tournamentId, userId);
+
+ await trx
+ .insertInto("TournamentTeamMember")
+ .values({
+ tournamentTeamId: newTeamId,
+ userId,
+ inGameName,
+ })
+ .execute();
+ });
+}
+
+export function del(tournamentTeamId: number) {
+ return db.transaction().execute(async (trx) => {
+ await trx
+ .deleteFrom("MapPoolMap")
+ .where("MapPoolMap.tournamentTeamId", "=", tournamentTeamId)
+ .execute();
+
+ await trx
+ .deleteFrom("TournamentTeam")
+ .where("TournamentTeam.id", "=", tournamentTeamId)
+ .execute();
+ });
+}
+
+export function leave({ teamId, userId }: { teamId: number; userId: number }) {
+ return db
+ .deleteFrom("TournamentTeamMember")
+ .where("TournamentTeamMember.tournamentTeamId", "=", teamId)
+ .where("TournamentTeamMember.userId", "=", userId)
+ .execute();
+}
+
+export function transferOwnership(
+ tournamentTeamId: number,
+ {
+ oldCaptainId,
+ newCaptainId,
+ }: { oldCaptainId: number; newCaptainId: number },
+) {
+ return db.transaction().execute(async (trx) => {
+ await trx
+ .updateTable("TournamentTeamMember")
+ .set({ role: "REGULAR" })
+ .where("TournamentTeamMember.tournamentTeamId", "=", tournamentTeamId)
+ .where("TournamentTeamMember.userId", "=", oldCaptainId)
+ .execute();
+
+ await trx
+ .updateTable("TournamentTeamMember")
+ .set({ role: "OWNER" })
+ .where("TournamentTeamMember.tournamentTeamId", "=", tournamentTeamId)
+ .where("TournamentTeamMember.userId", "=", newCaptainId)
+ .execute();
+ });
+}
+
+export function upsertCounterpickMaps({
+ tournamentTeamId,
+ mapPool,
+}: {
+ tournamentTeamId: Tables["TournamentTeam"]["id"];
+ mapPool: MapPool;
+}) {
+ return db.transaction().execute(async (trx) => {
+ await trx
+ .deleteFrom("MapPoolMap")
+ .where("MapPoolMap.tournamentTeamId", "=", tournamentTeamId)
+ .execute();
+
+ if (mapPool.stageModePairs.length > 0) {
+ await trx
+ .insertInto("MapPoolMap")
+ .values(
+ mapPool.stageModePairs.map(({ stageId, mode }) => ({
+ tournamentTeamId,
+ stageId,
+ mode,
+ })),
+ )
+ .execute();
+ }
+ });
+}
+
async function findTeamRecentMaps(teamId: number, limit: number) {
return db
.selectFrom("TournamentMatchGameResult")
@@ -375,6 +676,14 @@ async function findTeamRecentMaps(teamId: number, limit: number) {
.execute();
}
+export function findByInviteCode(inviteCode: string) {
+ return db
+ .selectFrom("TournamentTeam")
+ .select(["TournamentTeam.id", "TournamentTeam.tournamentId"])
+ .where("TournamentTeam.inviteCode", "=", inviteCode)
+ .executeTakeFirst();
+}
+
export async function findRecentlyPlayedMapsByIds({
teamIds,
limit = 5,
diff --git a/app/features/tournament/actions/to.$id.admin.server.ts b/app/features/tournament/actions/to.$id.admin.server.ts
index 31d5addf9..729e4ca66 100644
--- a/app/features/tournament/actions/to.$id.admin.server.ts
+++ b/app/features/tournament/actions/to.$id.admin.server.ts
@@ -3,6 +3,7 @@ import * as R from "remeda";
import { DANGEROUS_CAN_ACCESS_DEV_CONTROLS } from "~/features/admin/core/dev-controls";
import { requireUser } from "~/features/auth/core/user.server";
import { userIsBanned } from "~/features/ban/core/banned.server";
+import * as ChatSystemMessage from "~/features/chat/ChatSystemMessage.server";
import * as ShowcaseTournaments from "~/features/front-page/core/ShowcaseTournaments.server";
import { notify } from "~/features/notifications/core/notify.server";
import * as TournamentTeamRepository from "~/features/tournament/TournamentTeamRepository.server";
@@ -12,6 +13,10 @@ import {
clearTournamentDataCache,
tournamentFromDB,
} from "~/features/tournament-bracket/core/Tournament.server";
+import {
+ tournamentMatchWebsocketRoom,
+ tournamentWebsocketRoom,
+} from "~/features/tournament-bracket/tournament-bracket-utils";
import * as TournamentLFGRepository from "~/features/tournament-lfg/TournamentLFGRepository.server";
import * as UserRepository from "~/features/user-page/UserRepository.server";
import invariant from "~/utils/invariant";
@@ -25,15 +30,9 @@ import {
} from "~/utils/remix.server";
import { assertUnreachable } from "~/utils/types";
import { idObject } from "../../../utils/zod";
-import { changeTeamOwner } from "../queries/changeTeamOwner.server";
-import { deleteTeam } from "../queries/deleteTeam.server";
-import { joinTeam, leaveTeam } from "../queries/joinLeaveTeam.server";
import * as TournamentRepository from "../TournamentRepository.server";
import { adminActionSchema } from "../tournament-schemas.server";
-import {
- endDroppedTeamMatches,
- inGameNameIfNeeded,
-} from "../tournament-utils.server";
+import { endDroppedTeamMatches } from "../tournament-utils.server";
export const action: ActionFunction = async ({ request, params }) => {
const user = requireUser();
@@ -65,16 +64,14 @@ export const action: ActionFunction = async ({ request, params }) => {
!tournament.teamMemberOfByUser({ id: data.userId }),
"User already on a team",
);
+ const addTeamUser = await UserRepository.findLeanById(data.userId);
+ errorToastIfFalsy(addTeamUser?.friendCode, "User has no friend code set");
errorToastIfFalsy(
- (await UserRepository.findLeanById(data.userId))?.friendCode,
- "User has no friend code set",
+ !tournament.ctx.settings.requireInGameNames || addTeamUser?.inGameName,
+ "User has no in-game name set",
);
await TournamentTeamRepository.create({
- ownerInGameName: await inGameNameIfNeeded({
- tournament,
- userId: data.userId,
- }),
team: {
name: data.teamName,
prefersNotToHost: 0,
@@ -107,10 +104,9 @@ export const action: ActionFunction = async ({ request, params }) => {
const newCaptain = team.members.find((m) => m.userId === data.memberId);
errorToastIfFalsy(newCaptain, "Invalid member id");
- changeTeamOwner({
- newCaptainId: data.memberId,
+ await TournamentTeamRepository.transferOwnership(data.teamId, {
oldCaptainId: oldCaptain.userId,
- tournamentTeamId: data.teamId,
+ newCaptainId: data.memberId,
});
message = "Team owner changed";
@@ -121,7 +117,7 @@ export const action: ActionFunction = async ({ request, params }) => {
const team = tournament.teamById(data.teamId);
errorToastIfFalsy(team, "Invalid team id");
- await TournamentRepository.updateTeamName({
+ await TournamentTeamRepository.updateName({
tournamentTeamId: data.teamId,
name: data.teamName,
});
@@ -147,11 +143,11 @@ export const action: ActionFunction = async ({ request, params }) => {
invariant(bracket, "Invalid bracket idx");
errorToastIfFalsy(bracket.preview, "Bracket has been started");
- await TournamentRepository.checkIn({
- tournamentTeamId: data.teamId,
+ await TournamentTeamRepository.checkIn(
+ data.teamId,
// no sources = regular check in
- bracketIdx: !bracket.sources ? null : data.bracketIdx,
- });
+ bracket.sources ? { bracketIdx: data.bracketIdx } : undefined,
+ );
message = "Checked team in";
break;
@@ -169,7 +165,7 @@ export const action: ActionFunction = async ({ request, params }) => {
invariant(bracket, "Invalid bracket idx");
errorToastIfFalsy(bracket.preview, "Bracket has been started");
- await TournamentRepository.checkOut({
+ await TournamentTeamRepository.checkOut({
tournamentTeamId: data.teamId,
// no sources = regular check in
bracketIdx: !bracket.sources ? null : data.bracketIdx,
@@ -209,7 +205,7 @@ export const action: ActionFunction = async ({ request, params }) => {
});
}
- leaveTeam({
+ await TournamentTeamRepository.leave({
userId: data.memberId,
teamId: team.id,
});
@@ -245,16 +241,22 @@ export const action: ActionFunction = async ({ request, params }) => {
"User trying to be added currently has an active ban from sendou.ink",
);
+ const addMemberUser = await UserRepository.findLeanById(data.userId);
errorToastIfFalsy(
- (await UserRepository.findLeanById(data.userId))?.friendCode,
+ addMemberUser?.friendCode,
"User has no friend code set",
);
+ errorToastIfFalsy(
+ !tournament.ctx.settings.requireInGameNames ||
+ addMemberUser?.inGameName,
+ "User has no in-game name set",
+ );
await TournamentLFGRepository.leaveLfg({
userId: data.userId,
tournamentId,
});
- joinTeam({
+ await TournamentTeamRepository.join({
userId: data.userId,
newTeamId: team.id,
previousTeamId: previousTeam?.id,
@@ -265,11 +267,6 @@ export const action: ActionFunction = async ({ request, params }) => {
tournament.hasStarted
? "DELETE"
: undefined,
- tournamentId,
- inGameName: await inGameNameIfNeeded({
- tournament,
- userId: data.userId,
- }),
});
ShowcaseTournaments.addToCached({
@@ -305,7 +302,7 @@ export const action: ActionFunction = async ({ request, params }) => {
errorToastIfFalsy(team, "Invalid team id");
errorToastIfFalsy(!tournament.hasStarted, "Tournament has started");
- deleteTeam(team.id);
+ await TournamentTeamRepository.del(team.id);
for (const member of team.members) {
ShowcaseTournaments.removeFromCached({
@@ -396,26 +393,41 @@ export const action: ActionFunction = async ({ request, params }) => {
});
}
- endDroppedTeamMatches({
+ const endedMatchIds = endDroppedTeamMatches({
tournament,
manager: getServerTournamentManager(),
droppedTeamId: data.teamId,
});
- await TournamentRepository.dropTeamOut({
+ await TournamentTeamRepository.dropOut({
tournamentTeamId: data.teamId,
previewBracketIdxs: tournament.brackets.flatMap((b, idx) =>
b.preview ? idx : [],
),
});
+ if (endedMatchIds.length > 0) {
+ ChatSystemMessage.send([
+ ...endedMatchIds.map((matchId) => ({
+ room: tournamentMatchWebsocketRoom(matchId),
+ type: "TOURNAMENT_MATCH_UPDATED" as const,
+ revalidateOnly: true as const,
+ })),
+ {
+ room: tournamentWebsocketRoom(tournament.ctx.id),
+ type: "TOURNAMENT_UPDATED" as const,
+ revalidateOnly: true as const,
+ },
+ ]);
+ }
+
message = "Team dropped out";
break;
}
case "UNDO_DROP_TEAM_OUT": {
validateIsTournamentOrganizer();
- await TournamentRepository.undoDropTeamOut(data.teamId);
+ await TournamentTeamRepository.undoDropOut(data.teamId);
message = "Team drop out undone";
break;
diff --git a/app/features/tournament/actions/to.$id.join.server.ts b/app/features/tournament/actions/to.$id.join.server.ts
index 4dc5f70bb..e3f936462 100644
--- a/app/features/tournament/actions/to.$id.join.server.ts
+++ b/app/features/tournament/actions/to.$id.join.server.ts
@@ -2,6 +2,7 @@ import type { ActionFunction } from "react-router";
import { redirect } from "react-router";
import { requireUser } from "~/features/auth/core/user.server";
import * as ShowcaseTournaments from "~/features/front-page/core/ShowcaseTournaments.server";
+import * as TournamentTeamRepository from "~/features/tournament/TournamentTeamRepository.server";
import {
clearTournamentDataCache,
tournamentFromDB,
@@ -16,12 +17,10 @@ import {
} from "~/utils/remix.server";
import { tournamentPage } from "~/utils/urls";
import { idObject } from "~/utils/zod";
-import { findByInviteCode } from "../queries/findTeamByInviteCode.server";
-import { joinTeam } from "../queries/joinLeaveTeam.server";
import { validateCanJoinTeam } from "../tournament-utils";
import {
- inGameNameIfNeeded,
requireNotBannedByOrganization,
+ requireSendouQParticipationIfNeeded,
} from "../tournament-utils.server";
export const action: ActionFunction = async ({ request, params }) => {
@@ -34,7 +33,9 @@ export const action: ActionFunction = async ({ request, params }) => {
const inviteCode = url.searchParams.get("code");
invariant(inviteCode, "code is missing");
- const leanTeam = notFoundIfFalsy(findByInviteCode(inviteCode));
+ const leanTeam = notFoundIfFalsy(
+ await TournamentTeamRepository.findByInviteCode(inviteCode),
+ );
const tournament = await tournamentFromDB({ tournamentId, user });
@@ -42,6 +43,10 @@ export const action: ActionFunction = async ({ request, params }) => {
tournament,
user,
});
+ await requireSendouQParticipationIfNeeded({
+ tournament,
+ userId: user.id,
+ });
const teamToJoin = tournament.ctx.teams.find(
(team) => team.id === leanTeam.id,
@@ -83,7 +88,7 @@ export const action: ActionFunction = async ({ request, params }) => {
: "LEAVE";
await TournamentLFGRepository.leaveLfg({ userId: user.id, tournamentId });
- joinTeam({
+ await TournamentTeamRepository.join({
userId: user.id,
newTeamId: teamToJoin.id,
previousTeamId: previousTeam?.id,
@@ -94,11 +99,6 @@ export const action: ActionFunction = async ({ request, params }) => {
previousTeam &&
previousTeam.members.length <= tournament.minMembersPerTeam,
whatToDoWithPreviousTeam,
- tournamentId,
- inGameName: await inGameNameIfNeeded({
- tournament,
- userId: user.id,
- }),
});
ShowcaseTournaments.addToCached({
diff --git a/app/features/tournament/actions/to.$id.register.server.ts b/app/features/tournament/actions/to.$id.register.server.ts
index 77ac0a1fd..07c0c7eb8 100644
--- a/app/features/tournament/actions/to.$id.register.server.ts
+++ b/app/features/tournament/actions/to.$id.register.server.ts
@@ -22,12 +22,6 @@ import {
} from "~/utils/remix.server";
import { assertUnreachable } from "~/utils/types";
import { idObject } from "~/utils/zod";
-import { checkIn } from "../queries/checkIn.server";
-import { deleteTeam } from "../queries/deleteTeam.server";
-import deleteTeamMember from "../queries/deleteTeamMember.server";
-import { findOwnTournamentTeam } from "../queries/findOwnTournamentTeam.server";
-import { joinTeam } from "../queries/joinLeaveTeam.server";
-import { upsertCounterpickMaps } from "../queries/upsertCounterpickMaps.server";
import { TOURNAMENT } from "../tournament-constants";
import { registerSchema } from "../tournament-schemas.server";
import {
@@ -35,8 +29,8 @@ import {
validateCounterPickMapPool,
} from "../tournament-utils";
import {
- inGameNameIfNeeded,
requireNotBannedByOrganization,
+ requireSendouQParticipationIfNeeded,
} from "../tournament-utils.server";
export const action: ActionFunction = async ({ request, params }) => {
@@ -101,6 +95,10 @@ export const action: ActionFunction = async ({ request, params }) => {
tournament,
user,
});
+ await requireSendouQParticipationIfNeeded({
+ tournament,
+ userId: user.id,
+ });
errorToastIfFalsy(!tournament.isInvitational, "Event is invite only");
errorToastIfFalsy(
@@ -125,10 +123,6 @@ export const action: ActionFunction = async ({ request, params }) => {
tournamentId,
});
await TournamentTeamRepository.create({
- ownerInGameName: await inGameNameIfNeeded({
- tournament,
- userId: user.id,
- }),
team: {
name: data.teamName,
prefersNotToHost: Number(data.prefersNotToHost),
@@ -160,20 +154,18 @@ export const action: ActionFunction = async ({ request, params }) => {
);
errorToastIfFalsy(data.userId !== user.id, "Can't kick yourself");
- const detailedOwnTeam = findOwnTournamentTeam({
- tournamentId,
- userId: user.id,
- });
// making sure they aren't unfilling one checking in condition i.e. having full roster
// and then having members kicked without it affecting the checking in status
errorToastIfFalsy(
- detailedOwnTeam &&
- (!detailedOwnTeam.checkedInAt ||
- ownTeam.members.length > tournament.minMembersPerTeam),
+ !ownTeamCheckedIn ||
+ ownTeam.members.length > tournament.minMembersPerTeam,
"Can't kick a member after checking in",
);
- deleteTeamMember({ tournamentTeamId: ownTeam.id, userId: data.userId });
+ await TournamentTeamRepository.leave({
+ teamId: ownTeam.id,
+ userId: data.userId,
+ });
ShowcaseTournaments.removeFromCached({
tournamentId,
@@ -192,8 +184,8 @@ export const action: ActionFunction = async ({ request, params }) => {
"You cannot leave after checking in",
);
- deleteTeamMember({
- tournamentTeamId: teamMemberOf.id,
+ await TournamentTeamRepository.leave({
+ teamId: teamMemberOf.id,
userId: user.id,
});
@@ -220,7 +212,7 @@ export const action: ActionFunction = async ({ request, params }) => {
"Invalid map pool",
);
- upsertCounterpickMaps({
+ await TournamentTeamRepository.upsertCounterpickMaps({
tournamentTeamId: ownTeam.id,
mapPool: new MapPool(data.mapPool),
});
@@ -248,7 +240,7 @@ export const action: ActionFunction = async ({ request, params }) => {
`Can't check-in - ${tournament.checkInConditionsFulfilledByTeamId(teamMemberOf.id).reason}`,
);
- checkIn(teamMemberOf.id);
+ await TournamentTeamRepository.checkIn(teamMemberOf.id);
logger.info(
`Checking in (success): tournament team id: ${teamMemberOf.id} - user id: ${user.id} - tournament id: ${tournamentId}`,
);
@@ -279,19 +271,18 @@ export const action: ActionFunction = async ({ request, params }) => {
user: { id: data.userId },
message: "The user is banned from events hosted by this organization",
});
+ await requireSendouQParticipationIfNeeded({
+ tournament,
+ userId: data.userId,
+ });
await TournamentLFGRepository.leaveLfg({
userId: data.userId,
tournamentId,
});
- joinTeam({
+ await TournamentTeamRepository.join({
userId: data.userId,
newTeamId: ownTeam.id,
- tournamentId,
- inGameName: await inGameNameIfNeeded({
- tournament,
- userId: data.userId,
- }),
});
await SavedCalendarEventRepository.unsave({
@@ -335,7 +326,7 @@ export const action: ActionFunction = async ({ request, params }) => {
"Unregistering from leagues is not possible after registration has closed",
);
- deleteTeam(ownTeam.id);
+ await TournamentTeamRepository.del(ownTeam.id);
for (const member of ownTeam.members) {
ShowcaseTournaments.removeFromCached({
diff --git a/app/features/tournament/actions/to.$id.seeds.server.ts b/app/features/tournament/actions/to.$id.seeds.server.ts
index d27501387..df4539e07 100644
--- a/app/features/tournament/actions/to.$id.seeds.server.ts
+++ b/app/features/tournament/actions/to.$id.seeds.server.ts
@@ -68,6 +68,23 @@ export const action: ActionFunction = async ({ request, params }) => {
);
break;
}
+ case "UPDATE_AB_DIVISIONS": {
+ errorToastIfFalsy(
+ tournament.ctx.settings.bracketProgression.some(
+ (bracket) => !bracket.sources && bracket.settings?.hasAbDivisions,
+ ),
+ "No starting bracket has A/B divisions enabled",
+ );
+
+ const validTeamIds = new Set(tournament.ctx.teams.map((t) => t.id));
+ errorToastIfFalsy(
+ data.abDivisions.every((t) => validTeamIds.has(t.tournamentTeamId)),
+ "Invalid tournament team id",
+ );
+
+ await TournamentTeamRepository.updateAbDivisions(data.abDivisions);
+ break;
+ }
}
clearTournamentDataCache(tournamentId);
diff --git a/app/features/tournament/core/Standings.test.ts b/app/features/tournament/core/Standings.test.ts
new file mode 100644
index 000000000..4a6193390
--- /dev/null
+++ b/app/features/tournament/core/Standings.test.ts
@@ -0,0 +1,253 @@
+import { describe, expect, it } from "vitest";
+import {
+ progressions,
+ testTournament,
+ tournamentCtxTeam,
+} from "~/features/tournament-bracket/core/tests/test-utils";
+import { BracketsManager } from "~/modules/brackets-manager";
+import { InMemoryDatabase } from "~/modules/brackets-memory-db";
+import invariant from "~/utils/invariant";
+import { reNumberPlacements, tournamentStandings } from "./Standings";
+
+describe("tournamentStandings", () => {
+ it("returns single-division standings for a tournament with one starting bracket", () => {
+ const tournament = singleEliminationTournament();
+
+ const result = tournamentStandings(tournament);
+
+ expect(result.type).toBe("single");
+ invariant(result.type === "single");
+ expect(result.standings.length).toBeGreaterThan(0);
+ expect(result.standings[0].placement).toBe(1);
+ expect(result.standings[0].team.id).toBe(1);
+ });
+
+ it("returns one div per starting bracket for a tournament with multiple starting brackets", () => {
+ const tournament = testTournament({
+ ctx: {
+ settings: { bracketProgression: progressions.manyStartBrackets },
+ teams: [
+ tournamentCtxTeam(1, { startingBracketIdx: 0, seed: 1 }),
+ tournamentCtxTeam(2, { startingBracketIdx: 0, seed: 2 }),
+ tournamentCtxTeam(3, { startingBracketIdx: 1, seed: 3 }),
+ tournamentCtxTeam(4, { startingBracketIdx: 1, seed: 4 }),
+ ],
+ },
+ });
+
+ const result = tournamentStandings(tournament);
+
+ expect(result.type).toBe("multi");
+ invariant(result.type === "multi");
+ expect(result.standings).toHaveLength(2);
+ for (const { div } of result.standings) {
+ expect(typeof div).toBe("string");
+ expect(div.length).toBeGreaterThan(0);
+ }
+ const divs = result.standings.map((s) => s.div);
+ expect(new Set(divs).size).toBe(2);
+ });
+
+ it("splits A/B divisions finals into 'A' and 'B' divs with teams partitioned by abDivision", () => {
+ const tournament = abDivisionsTournament();
+
+ const result = tournamentStandings(tournament);
+
+ expect(result.type).toBe("multi");
+ invariant(result.type === "multi");
+ expect(result.standings.map((s) => s.div)).toEqual(["A", "B"]);
+
+ const [a, b] = result.standings;
+ expect(a.standings.map((s) => s.team.id)).toEqual([1, 3]);
+ expect(b.standings.map((s) => s.team.id)).toEqual([2, 4]);
+ expect(a.standings.every((s) => s.team.abDivision === 0)).toBe(true);
+ expect(b.standings.every((s) => s.team.abDivision === 1)).toBe(true);
+ });
+
+ it("re-numbers placements within each A/B division starting from 1", () => {
+ const tournament = abDivisionsTournament();
+
+ const result = tournamentStandings(tournament);
+
+ invariant(result.type === "multi");
+ const [a, b] = result.standings;
+ expect(a.standings.map((s) => s.placement)).toEqual([1, 2]);
+ expect(b.standings.map((s) => s.placement)).toEqual([1, 2]);
+ });
+});
+
+describe("reNumberPlacements", () => {
+ it("keeps already contiguous placements unchanged", () => {
+ const result = reNumberPlacements([
+ { placement: 1 },
+ { placement: 2 },
+ { placement: 3 },
+ ]);
+
+ expect(result.map((s) => s.placement)).toEqual([1, 2, 3]);
+ });
+
+ it("groups tied placements and skips numbers to match team count", () => {
+ const result = reNumberPlacements([
+ { placement: 1 },
+ { placement: 1 },
+ { placement: 3 },
+ { placement: 3 },
+ { placement: 5 },
+ ]);
+
+ expect(result.map((s) => s.placement)).toEqual([1, 1, 3, 3, 5]);
+ });
+
+ it("re-numbers from 1 when the input has been filtered (e.g. top finishers removed)", () => {
+ const result = reNumberPlacements([
+ { placement: 3 },
+ { placement: 3 },
+ { placement: 5 },
+ { placement: 7 },
+ ]);
+
+ expect(result.map((s) => s.placement)).toEqual([1, 1, 3, 4]);
+ });
+
+ it("adds the offset to every placement", () => {
+ const result = reNumberPlacements(
+ [{ placement: 1 }, { placement: 1 }, { placement: 3 }],
+ 10,
+ );
+
+ expect(result.map((s) => s.placement)).toEqual([11, 11, 13]);
+ });
+
+ it("preserves non-placement fields on each standing", () => {
+ const result = reNumberPlacements([
+ { placement: 1, team: { id: 7 }, note: "a" },
+ { placement: 2, team: { id: 8 }, note: "b" },
+ ]);
+
+ expect(result).toEqual([
+ { placement: 1, team: { id: 7 }, note: "a" },
+ { placement: 2, team: { id: 8 }, note: "b" },
+ ]);
+ });
+
+ it("returns an empty array when given an empty array", () => {
+ expect(reNumberPlacements([])).toEqual([]);
+ expect(reNumberPlacements([], 5)).toEqual([]);
+ });
+});
+
+function singleEliminationTournament() {
+ const storage = new InMemoryDatabase();
+ const manager = new BracketsManager(storage);
+
+ manager.create({
+ name: "Main Bracket",
+ tournamentId: 1,
+ type: "single_elimination",
+ seeding: [1, 2, 3, 4],
+ settings: { seedOrdering: ["natural"] },
+ });
+
+ while (true) {
+ const pending = storage
+ .select("match")!
+ .find(
+ (m) =>
+ typeof m.opponent1?.id === "number" &&
+ typeof m.opponent2?.id === "number" &&
+ m.opponent1.result !== "win" &&
+ m.opponent2.result !== "win",
+ );
+ if (!pending) break;
+
+ const winnerIsOpp1 = pending.opponent1.id < pending.opponent2.id;
+ manager.update.match({
+ id: pending.id,
+ opponent1: winnerIsOpp1 ? { score: 2, result: "win" } : { score: 0 },
+ opponent2: winnerIsOpp1 ? { score: 0 } : { score: 2, result: "win" },
+ });
+ }
+
+ return testTournament({
+ ctx: {
+ settings: {
+ bracketProgression: progressions.singleElimination,
+ },
+ teams: [
+ tournamentCtxTeam(1, { seed: 1 }),
+ tournamentCtxTeam(2, { seed: 2 }),
+ tournamentCtxTeam(3, { seed: 3 }),
+ tournamentCtxTeam(4, { seed: 4 }),
+ ],
+ },
+ data: manager.get.tournamentData(1),
+ });
+}
+
+function abDivisionsTournament() {
+ const storage = new InMemoryDatabase();
+ const manager = new BracketsManager(storage);
+
+ manager.create({
+ name: "AB RR",
+ tournamentId: 1,
+ type: "round_robin",
+ seeding: [1, 2, 3, 4],
+ abDivisions: [0, 1, 0, 1],
+ settings: {
+ groupCount: 1,
+ hasAbDivisions: true,
+ seedOrdering: ["groups.seed_optimized"],
+ },
+ });
+
+ const winnerByMatchup: Record = {
+ "1-2": 1,
+ "1-4": 1,
+ "2-3": 2,
+ "3-4": 3,
+ };
+ for (const match of storage.select("match")!) {
+ const a = match.opponent1.id as number;
+ const b = match.opponent2.id as number;
+ const key = a < b ? `${a}-${b}` : `${b}-${a}`;
+ const winnerId = winnerByMatchup[key];
+ invariant(winnerId, `unexpected matchup ${key}`);
+ const loserScore = key === "2-3" || key === "3-4" ? 1 : 0;
+ const winnerIsOpp1 = match.opponent1.id === winnerId;
+ manager.update.match({
+ id: match.id,
+ opponent1: winnerIsOpp1
+ ? { score: 2, result: "win" }
+ : { score: loserScore },
+ opponent2: winnerIsOpp1
+ ? { score: loserScore }
+ : { score: 2, result: "win" },
+ });
+ }
+
+ const data = manager.get.tournamentData(1);
+
+ return testTournament({
+ ctx: {
+ settings: {
+ bracketProgression: [
+ {
+ type: "round_robin",
+ name: "AB RR",
+ requiresCheckIn: false,
+ settings: { hasAbDivisions: true },
+ },
+ ],
+ },
+ teams: [
+ tournamentCtxTeam(1, { abDivision: 0, seed: 1 }),
+ tournamentCtxTeam(2, { abDivision: 1, seed: 2 }),
+ tournamentCtxTeam(3, { abDivision: 0, seed: 3 }),
+ tournamentCtxTeam(4, { abDivision: 1, seed: 4 }),
+ ],
+ },
+ data,
+ });
+}
diff --git a/app/features/tournament/core/Standings.ts b/app/features/tournament/core/Standings.ts
index a2fa012ce..d6894df4a 100644
--- a/app/features/tournament/core/Standings.ts
+++ b/app/features/tournament/core/Standings.ts
@@ -24,6 +24,34 @@ export function flattenStandings(
: standingsResult.standings.flatMap((div) => div.standings);
}
+/**
+ * Re-numbers placements in a sorted standings array so that tied placements stay
+ * grouped (e.g. `[1, 1, 3, 3, 5]`) while non-tied positions reflect the true
+ * number of teams above them. Useful after filtering or merging standings where
+ * the original placement numbers no longer match the team count.
+ *
+ * Pass `offset` to shift every placement downwards — used when the returned
+ * standings will be appended below standings from another bracket.
+ */
+export function reNumberPlacements(
+ standings: T[],
+ offset = 0,
+): T[] {
+ let lastOriginalPlacement = 0;
+ let currentPlacement = 0;
+
+ return standings.map((standing, index) => {
+ if (standing.placement !== lastOriginalPlacement) {
+ lastOriginalPlacement = standing.placement;
+ currentPlacement = index + 1;
+ }
+ return {
+ ...standing,
+ placement: currentPlacement + offset,
+ };
+ });
+}
+
/** Calculates SPR (Seed Performance Rating) - see https://web.archive.org/web/20250513034545/https://www.pgstats.com/articles/introducing-spr-and-uf */
export function calculateSPR({
standings,
@@ -143,24 +171,42 @@ export function matchesPlayed({
export function tournamentStandings(
tournament: Tournament,
): TournamentStandingsResult {
- const startingBracketIdxs = Progression.startingBrackets(
- tournament.ctx.settings.bracketProgression,
- );
+ const progression = tournament.ctx.settings.bracketProgression;
+ const startingBracketIdxs = Progression.startingBrackets(progression);
if (startingBracketIdxs.length <= 1) {
+ const standings = tournamentStandingsForBracket(tournament, undefined);
+
+ if (Progression.hasAbDivisionsFinals(progression)) {
+ return {
+ type: "multi",
+ standings: [
+ {
+ div: "A",
+ standings: reNumberPlacements(
+ standings.filter((s) => s.team.abDivision === 0),
+ ),
+ },
+ {
+ div: "B",
+ standings: reNumberPlacements(
+ standings.filter((s) => s.team.abDivision === 1),
+ ),
+ },
+ ],
+ };
+ }
+
return {
type: "single",
- standings: tournamentStandingsForBracket(tournament, undefined),
+ standings,
};
}
return {
type: "multi",
standings: startingBracketIdxs.map((bracketIdx) => ({
- div: getBracketProgressionLabel(
- bracketIdx,
- tournament.ctx.settings.bracketProgression,
- ),
+ div: getBracketProgressionLabel(bracketIdx, progression),
standings: tournamentStandingsForBracket(tournament, bracketIdx),
})),
};
@@ -241,8 +287,6 @@ function standingsToMergeable<
standings: T[];
teamsAboveFromAnotherBracketsCount: number;
}) {
- const result: T[] = [];
-
const filtered = standings.filter(
(standing) => !alreadyIncludedTeamIds.has(standing.team.id),
);
@@ -250,22 +294,8 @@ function standingsToMergeable<
// e.g. if standings start at 3rd place, this must mean there is 2 teams left to finish _this_ bracket
const unfinishedTeamsCount = (standings.at(0)?.placement ?? 1) - 1;
- let placement = 1;
-
- for (const [i, standing] of filtered.entries()) {
- const placementChanged =
- i !== 0 && standing.placement !== filtered[i - 1].placement;
-
- if (placementChanged) {
- placement = i + 1;
- }
-
- result.push({
- ...standing,
- placement:
- placement + teamsAboveFromAnotherBracketsCount + unfinishedTeamsCount,
- });
- }
-
- return result;
+ return reNumberPlacements(
+ filtered,
+ teamsAboveFromAnotherBracketsCount + unfinishedTeamsCount,
+ );
}
diff --git a/app/features/tournament/loaders/to.$id.join.server.ts b/app/features/tournament/loaders/to.$id.join.server.ts
index e22a0e73c..7a092b567 100644
--- a/app/features/tournament/loaders/to.$id.join.server.ts
+++ b/app/features/tournament/loaders/to.$id.join.server.ts
@@ -1,12 +1,16 @@
import type { LoaderFunctionArgs } from "react-router";
-import { findByInviteCode } from "../queries/findTeamByInviteCode.server";
+import * as TournamentTeamRepository from "~/features/tournament/TournamentTeamRepository.server";
-export const loader = ({ request }: LoaderFunctionArgs) => {
+export const loader = async ({ request }: LoaderFunctionArgs) => {
const url = new URL(request.url);
const inviteCode = url.searchParams.get("code");
+ const team = inviteCode
+ ? await TournamentTeamRepository.findByInviteCode(inviteCode)
+ : null;
+
return {
- teamId: inviteCode ? findByInviteCode(inviteCode)?.id : null,
+ teamId: team?.id ?? null,
inviteCode,
};
};
diff --git a/app/features/tournament/loaders/to.$id.register.server.ts b/app/features/tournament/loaders/to.$id.register.server.ts
index 378ce2472..98ca13c1f 100644
--- a/app/features/tournament/loaders/to.$id.register.server.ts
+++ b/app/features/tournament/loaders/to.$id.register.server.ts
@@ -3,10 +3,10 @@ import { getUser } from "~/features/auth/core/user.server";
import * as SQGroupRepository from "~/features/sendouq/SQGroupRepository.server";
import * as TeamRepository from "~/features/team/TeamRepository.server";
import * as SavedCalendarEventRepository from "~/features/tournament/SavedCalendarEventRepository.server";
+import { tournamentFromDBCached } from "~/features/tournament-bracket/core/Tournament.server";
import { findMapPoolByTeamId } from "~/features/tournament-bracket/queries/findMapPoolByTeamId.server";
import { parseParams } from "~/utils/remix.server";
import { idObject } from "~/utils/zod";
-import { findOwnTournamentTeam } from "../queries/findOwnTournamentTeam.server";
export const loader = async ({ params }: LoaderFunctionArgs) => {
const user = getUser();
@@ -17,11 +17,10 @@ export const loader = async ({ params }: LoaderFunctionArgs) => {
schema: idObject,
});
- const ownTournamentTeam = findOwnTournamentTeam({
- tournamentId,
- userId: user.id,
- });
- if (!ownTournamentTeam) {
+ const tournament = await tournamentFromDBCached({ tournamentId, user });
+ const ownTeam = tournament.ownedTeamByUser(user);
+
+ if (!ownTeam) {
return {
mapPool: null,
friendPlayers: null,
@@ -34,7 +33,7 @@ export const loader = async ({ params }: LoaderFunctionArgs) => {
}
return {
- mapPool: findMapPoolByTeamId(ownTournamentTeam.id),
+ mapPool: findMapPoolByTeamId(ownTeam.id),
friendPlayers: await SQGroupRepository.friendsAndTeammates(user.id),
teams: await TeamRepository.findAllMemberOfByUserId(user.id),
isSaved: false,
diff --git a/app/features/tournament/queries/changeTeamOwner.server.ts b/app/features/tournament/queries/changeTeamOwner.server.ts
deleted file mode 100644
index 062c320f0..000000000
--- a/app/features/tournament/queries/changeTeamOwner.server.ts
+++ /dev/null
@@ -1,30 +0,0 @@
-import { sql } from "~/db/sql";
-import type { Tables } from "~/db/tables";
-
-const stm = sql.prepare(/* sql */ `
- update TournamentTeamMember
- set "role" = @role
- where
- "tournamentTeamId" = @tournamentTeamId and
- "userId" = @userId
-`);
-
-export const changeTeamOwner = sql.transaction(
- (args: {
- tournamentTeamId: Tables["TournamentTeam"]["id"];
- oldCaptainId: Tables["User"]["id"];
- newCaptainId: Tables["User"]["id"];
- }) => {
- stm.run({
- tournamentTeamId: args.tournamentTeamId,
- userId: args.oldCaptainId,
- role: "REGULAR",
- });
-
- stm.run({
- tournamentTeamId: args.tournamentTeamId,
- userId: args.newCaptainId,
- role: "OWNER",
- });
- },
-);
diff --git a/app/features/tournament/queries/checkIn.server.ts b/app/features/tournament/queries/checkIn.server.ts
deleted file mode 100644
index 24fa1888e..000000000
--- a/app/features/tournament/queries/checkIn.server.ts
+++ /dev/null
@@ -1,12 +0,0 @@
-import { sql } from "~/db/sql";
-
-const stm = sql.prepare(/* sql */ `
- insert into "TournamentTeamCheckIn"
- ("tournamentTeamId", "checkedInAt")
- values
- (@tournamentTeamId, strftime('%s', 'now'))
-`);
-
-export function checkIn(tournamentTeamId: number) {
- stm.run({ tournamentTeamId });
-}
diff --git a/app/features/tournament/queries/checkOut.server.ts b/app/features/tournament/queries/checkOut.server.ts
deleted file mode 100644
index c26068e86..000000000
--- a/app/features/tournament/queries/checkOut.server.ts
+++ /dev/null
@@ -1,10 +0,0 @@
-import { sql } from "~/db/sql";
-
-const stm = sql.prepare(/* sql */ `
- delete from "TournamentTeamCheckIn"
- where "tournamentTeamId" = @tournamentTeamId
-`);
-
-export function checkOut(tournamentTeamId: number) {
- stm.run({ tournamentTeamId });
-}
diff --git a/app/features/tournament/queries/deleteTeam.server.ts b/app/features/tournament/queries/deleteTeam.server.ts
deleted file mode 100644
index fb2a6adc3..000000000
--- a/app/features/tournament/queries/deleteTeam.server.ts
+++ /dev/null
@@ -1,16 +0,0 @@
-import { sql } from "~/db/sql";
-
-const deleteTeamStm = sql.prepare(/*sql*/ `
- delete from "TournamentTeam"
- where "id" = @tournamentTeamId
-`);
-
-const deleteMapPoolStm = sql.prepare(/*sql*/ `
- delete from "MapPoolMap"
- where "tournamentTeamId" = @tournamentTeamId
-`);
-
-export const deleteTeam = sql.transaction((tournamentTeamId: number) => {
- deleteMapPoolStm.run({ tournamentTeamId });
- deleteTeamStm.run({ tournamentTeamId });
-});
diff --git a/app/features/tournament/queries/deleteTeamMember.server.ts b/app/features/tournament/queries/deleteTeamMember.server.ts
deleted file mode 100644
index dfca7b6bb..000000000
--- a/app/features/tournament/queries/deleteTeamMember.server.ts
+++ /dev/null
@@ -1,17 +0,0 @@
-import { sql } from "~/db/sql";
-
-const stm = sql.prepare(/*sql*/ `
- delete from "TournamentTeamMember"
- where userId = @userId
- and tournamentTeamId = @tournamentTeamId
-`);
-
-export default function deleteTeamMember({
- userId,
- tournamentTeamId,
-}: {
- userId: number;
- tournamentTeamId: number;
-}) {
- stm.run({ userId, tournamentTeamId });
-}
diff --git a/app/features/tournament/queries/findOwnTournamentTeam.server.ts b/app/features/tournament/queries/findOwnTournamentTeam.server.ts
deleted file mode 100644
index 5c04499a4..000000000
--- a/app/features/tournament/queries/findOwnTournamentTeam.server.ts
+++ /dev/null
@@ -1,39 +0,0 @@
-import { sql } from "~/db/sql";
-import type { Tables } from "~/db/tables";
-
-const stm = sql.prepare(/*sql*/ `
- select
- "TournamentTeam"."id",
- "TournamentTeam"."name",
- "TournamentTeamCheckIn"."checkedInAt",
- "TournamentTeam"."inviteCode"
- from
- "TournamentTeam"
- left join "TournamentTeamCheckIn" on
- "TournamentTeamCheckIn"."tournamentTeamId" = "TournamentTeam"."id"
- left join "TournamentTeamMember" on
- "TournamentTeamMember"."tournamentTeamId" = "TournamentTeam"."id"
- and "TournamentTeamMember"."role" = 'OWNER'
- where
- "TournamentTeam"."tournamentId" = @tournamentId
- and "TournamentTeam"."isPlaceholder" = 0
- and "TournamentTeamMember"."userId" = @userId
-`);
-
-type FindOwnTeam =
- | (Pick &
- Pick)
- | null;
-
-export function findOwnTournamentTeam({
- tournamentId,
- userId,
-}: {
- tournamentId: number;
- userId: number;
-}) {
- return stm.get({
- tournamentId,
- userId,
- }) as FindOwnTeam;
-}
diff --git a/app/features/tournament/queries/findTeamByInviteCode.server.ts b/app/features/tournament/queries/findTeamByInviteCode.server.ts
deleted file mode 100644
index 8dcd6fa48..000000000
--- a/app/features/tournament/queries/findTeamByInviteCode.server.ts
+++ /dev/null
@@ -1,16 +0,0 @@
-import { sql } from "~/db/sql";
-
-const stm = sql.prepare(/*sql */ `
- select
- "TournamentTeam"."id",
- "TournamentTeam"."tournamentId"
- from "TournamentTeam"
- where "TournamentTeam"."inviteCode" = @inviteCode
-`);
-
-export function findByInviteCode(inviteCode: string) {
- return stm.get({ inviteCode }) as {
- id: number;
- tournamentId: number;
- } | null;
-}
diff --git a/app/features/tournament/queries/hasTournamentFinalized.server.ts b/app/features/tournament/queries/hasTournamentFinalized.server.ts
deleted file mode 100644
index af5a232aa..000000000
--- a/app/features/tournament/queries/hasTournamentFinalized.server.ts
+++ /dev/null
@@ -1,14 +0,0 @@
-import { sql } from "~/db/sql";
-import type { Tables } from "~/db/tables";
-
-const stm = sql.prepare(/*sql*/ `
- select 1
- from "TournamentResult"
- where "TournamentResult"."tournamentId" = @tournamentId
-`);
-
-export default function hasTournamentFinalized(
- tournamentId: Tables["Tournament"]["id"],
-) {
- return Boolean(stm.get({ tournamentId }));
-}
diff --git a/app/features/tournament/queries/hasTournamentStarted.server.ts b/app/features/tournament/queries/hasTournamentStarted.server.ts
deleted file mode 100644
index a1047d0a3..000000000
--- a/app/features/tournament/queries/hasTournamentStarted.server.ts
+++ /dev/null
@@ -1,14 +0,0 @@
-import { sql } from "~/db/sql";
-import type { Tables } from "~/db/tables";
-
-const stm = sql.prepare(/*sql*/ `
- select 1
- from "TournamentStage"
- where "TournamentStage"."tournamentId" = @tournamentId
-`);
-
-export default function hasTournamentStarted(
- tournamentId: Tables["Tournament"]["id"],
-) {
- return Boolean(stm.get({ tournamentId }));
-}
diff --git a/app/features/tournament/queries/joinLeaveTeam.server.ts b/app/features/tournament/queries/joinLeaveTeam.server.ts
deleted file mode 100644
index 8c81e01f2..000000000
--- a/app/features/tournament/queries/joinLeaveTeam.server.ts
+++ /dev/null
@@ -1,76 +0,0 @@
-import { sql } from "~/db/sql";
-import invariant from "~/utils/invariant";
-import { checkOut } from "./checkOut.server";
-
-const createTeamMemberStm = sql.prepare(/*sql*/ `
- insert into "TournamentTeamMember" (
- "tournamentTeamId",
- "inGameName",
- "userId"
- ) values (
- @tournamentTeamId,
- @inGameName,
- @userId
- )
-`);
-
-const deleteTeamStm = sql.prepare(/*sql*/ `
- delete from "TournamentTeam"
- where "id" = @tournamentTeamId
-`);
-
-const deleteMemberStm = sql.prepare(/*sql*/ `
- delete from "TournamentTeamMember"
- where "tournamentTeamId" = @tournamentTeamId
- and "userId" = @userId
-`);
-
-export const joinTeam = sql.transaction(
- ({
- previousTeamId,
- whatToDoWithPreviousTeam,
- newTeamId,
- userId,
- inGameName,
- tournamentId: _tournamentId,
- checkOutTeam = false,
- }: {
- previousTeamId?: number;
- whatToDoWithPreviousTeam?: "LEAVE" | "DELETE";
- newTeamId: number;
- userId: number;
- inGameName: string | null;
- tournamentId: number;
- checkOutTeam?: boolean;
- }) => {
- if (whatToDoWithPreviousTeam === "DELETE") {
- deleteTeamStm.run({ tournamentTeamId: previousTeamId ?? null });
- } else if (whatToDoWithPreviousTeam === "LEAVE") {
- deleteMemberStm.run({ tournamentTeamId: previousTeamId ?? null, userId });
- }
-
- if (checkOutTeam) {
- invariant(
- previousTeamId,
- "previousTeamId is required when checking out team",
- );
- checkOut(previousTeamId);
- }
-
- createTeamMemberStm.run({
- tournamentTeamId: newTeamId,
- userId,
- inGameName,
- });
- },
-);
-
-export const leaveTeam = ({
- teamId,
- userId,
-}: {
- teamId: number;
- userId: number;
-}) => {
- deleteMemberStm.run({ tournamentTeamId: teamId, userId });
-};
diff --git a/app/features/tournament/queries/upsertCounterpickMaps.server.ts b/app/features/tournament/queries/upsertCounterpickMaps.server.ts
deleted file mode 100644
index c123c4ec2..000000000
--- a/app/features/tournament/queries/upsertCounterpickMaps.server.ts
+++ /dev/null
@@ -1,37 +0,0 @@
-import { sql } from "~/db/sql";
-import type { Tables } from "~/db/tables";
-import type { MapPool } from "~/features/map-list-generator/core/map-pool";
-
-const deleteCounterpickMapsByTeamIdStm = sql.prepare(/* sql */ `
- delete from
- "MapPoolMap"
- where
- "tournamentTeamId" = @tournamentTeamId
-`);
-
-const addCounterpickMapStm = sql.prepare(/* sql */ `
- insert into
- "MapPoolMap" ("tournamentTeamId", "stageId", "mode")
- values
- (@tournamentTeamId, @stageId, @mode)
-`);
-
-export const upsertCounterpickMaps = sql.transaction(
- ({
- tournamentTeamId,
- mapPool,
- }: {
- tournamentTeamId: Tables["TournamentTeam"]["id"];
- mapPool: MapPool;
- }) => {
- deleteCounterpickMapsByTeamIdStm.run({ tournamentTeamId });
-
- for (const { stageId, mode } of mapPool.stageModePairs) {
- addCounterpickMapStm.run({
- tournamentTeamId,
- stageId,
- mode,
- });
- }
- },
-);
diff --git a/app/features/tournament/routes/to.$id.index.ts b/app/features/tournament/routes/to.$id.index.ts
index 7ee47f7f1..4c5d2c1c0 100644
--- a/app/features/tournament/routes/to.$id.index.ts
+++ b/app/features/tournament/routes/to.$id.index.ts
@@ -1,4 +1,5 @@
import { type LoaderFunctionArgs, redirect } from "react-router";
+import { tournamentFromDBCached } from "~/features/tournament-bracket/core/Tournament.server";
import { parseParams } from "~/utils/remix.server";
import {
tournamentBracketsPage,
@@ -6,20 +7,23 @@ import {
tournamentResultsPage,
} from "~/utils/urls";
import { idObject } from "~/utils/zod";
-import hasTournamentFinalized from "../queries/hasTournamentFinalized.server";
-import hasTournamentStarted from "../queries/hasTournamentStarted.server";
-export const loader = ({ params }: LoaderFunctionArgs) => {
+export const loader = async ({ params }: LoaderFunctionArgs) => {
const { id: tournamentId } = parseParams({
params,
schema: idObject,
});
- if (!hasTournamentStarted(tournamentId)) {
+ const tournament = await tournamentFromDBCached({
+ tournamentId,
+ user: undefined,
+ });
+
+ if (!tournament.hasStarted) {
return redirect(tournamentRegisterPage(tournamentId));
}
- if (!hasTournamentFinalized(tournamentId)) {
+ if (!tournament.ctx.isFinalized) {
return redirect(tournamentBracketsPage({ tournamentId }));
}
diff --git a/app/features/tournament/routes/to.$id.register.tsx b/app/features/tournament/routes/to.$id.register.tsx
index 2e58cc7f5..11d44cbb9 100644
--- a/app/features/tournament/routes/to.$id.register.tsx
+++ b/app/features/tournament/routes/to.$id.register.tsx
@@ -1381,15 +1381,12 @@ function TOPickedMapPoolInfo() {
-
-
+
+
+
+
);
diff --git a/app/features/tournament/routes/to.$id.seeds.tsx b/app/features/tournament/routes/to.$id.seeds.tsx
index df87d5f6c..b74416eca 100644
--- a/app/features/tournament/routes/to.$id.seeds.tsx
+++ b/app/features/tournament/routes/to.$id.seeds.tsx
@@ -23,23 +23,36 @@ import { Alert } from "~/components/Alert";
import { Avatar } from "~/components/Avatar";
import { Catcher } from "~/components/Catcher";
import { SendouButton } from "~/components/elements/Button";
+import {
+ SendouChipRadio,
+ SendouChipRadioGroup,
+} from "~/components/elements/ChipRadio";
import { SendouDialog } from "~/components/elements/Dialog";
import { Image } from "~/components/Image";
import { InfoPopover } from "~/components/InfoPopover";
import { SubmitButton } from "~/components/SubmitButton";
import { Table } from "~/components/Table";
import type { SeedingSnapshot } from "~/db/tables";
+import * as AbDivisions from "~/features/tournament-bracket/core/AbDivisions";
+import type { Tournament } from "~/features/tournament-bracket/core/Tournament";
import type { TournamentDataTeam } from "~/features/tournament-bracket/core/Tournament.server";
import invariant from "~/utils/invariant";
import { navIconUrl, userResultsPage } from "~/utils/urls";
import { ordinalToRoundedSp } from "../../mmr/mmr-utils";
import { action } from "../actions/to.$id.seeds.server";
import { loader } from "../loaders/to.$id.seeds.server";
+import { TOURNAMENT } from "../tournament-constants";
import { useTournament } from "./to.$id";
import styles from "./to.$id.seeds.module.css";
export { action, loader };
+const AB_DIVISION_RADIO_OPTIONS = [
+ { value: "unassigned", label: "Unassigned" },
+ { value: "0", label: "A" },
+ { value: "1", label: "B" },
+] as const;
+
export default function TournamentSeedsPage() {
const tournament = useTournament();
const navigation = useNavigation();
@@ -161,6 +174,16 @@ export default function TournamentSeedsPage() {
.join()}
/>
) : null}
+ {hasAbDivisionsStartingBracket(tournament) ? (
+ <>
+ team.abDivision ?? -1)
+ .join()}
+ />
+
@@ -431,6 +454,183 @@ function StartingBracketDialog() {
);
}
+function hasAbDivisionsStartingBracket(tournament: Tournament) {
+ return tournament.ctx.settings.bracketProgression.some(
+ (bracket) => !bracket.sources && bracket.settings?.hasAbDivisions,
+ );
+}
+
+function AbDivisionImbalanceWarning() {
+ const tournament = useTournament();
+
+ const warnings = tournament.ctx.settings.bracketProgression
+ .map((bracket, bracketIdx) => {
+ if (bracket.sources || !bracket.settings?.hasAbDivisions) return null;
+
+ const bracketTeams = tournament.isMultiStartingBracket
+ ? tournament.ctx.teams.filter(
+ (team) => (team.startingBracketIdx ?? 0) === bracketIdx,
+ )
+ : tournament.ctx.teams;
+ const checkedInTeams = bracketTeams.filter(
+ (team) => team.checkIns.length > 0,
+ );
+
+ const { a, b } = AbDivisions.countByDivision(checkedInTeams);
+ const diff = Math.abs(a - b);
+
+ const teamsPerGroup =
+ bracket.settings.teamsPerGroup ??
+ TOURNAMENT.RR_DEFAULT_TEAM_COUNT_PER_GROUP;
+ const groupCount = Math.max(
+ 1,
+ Math.ceil(checkedInTeams.length / teamsPerGroup),
+ );
+
+ const tooImbalanced = diff > 1;
+ const unevenWithMultipleGroups = diff === 1 && groupCount > 1;
+ if (!tooImbalanced && !unevenWithMultipleGroups) return null;
+
+ const prefix = tournament.isMultiStartingBracket
+ ? `${bracket.name}: `
+ : "";
+ const reason = tooImbalanced
+ ? "counts can differ by at most 1 to start bracket"
+ : "uneven A/B is only allowed with a single group";
+
+ return `${prefix}${a} checked-in A teams, ${b} checked-in B teams — ${reason}.`;
+ })
+ .filter((warning): warning is string => warning !== null);
+
+ if (warnings.length === 0) return null;
+
+ return (
+
+
+ {warnings.map((warning) => (
+
{warning}
+ ))}
+
+ );
+}
+
+type AbDivisionValue = 0 | 1 | null;
+
+function AbDivisionsDialog() {
+ const fetcher = useFetcher();
+ const tournament = useTournament();
+
+ const [isOpen, setIsOpen] = React.useState(false);
+ const [teamAbDivisions, setTeamAbDivisions] = React.useState<
+ { tournamentTeamId: number; abDivision: AbDivisionValue }[]
+ >(
+ tournament.ctx.teams.map((team) => ({
+ tournamentTeamId: team.id,
+ abDivision:
+ team.abDivision === 0 || team.abDivision === 1 ? team.abDivision : null,
+ })),
+ );
+
+ const counts = AbDivisions.countByDivision(teamAbDivisions);
+
+ return (
+
+
setIsOpen(true)}
+ data-testid="set-ab-divisions"
+ >
+ Set A/B divisions
+
+
setIsOpen(false)}
+ isFullScreen
+ >
+
+
+ A: {counts.a}
+ B: {counts.b}
+ Unassigned: {counts.unassigned}
+
+
+
+
+ Team
+ Division
+
+
+
+ {tournament.ctx.teams.map((team) => {
+ const { abDivision } = teamAbDivisions.find(
+ ({ tournamentTeamId }) => tournamentTeamId === team.id,
+ )!;
+
+ return (
+
+ {team.name}
+
+
+ {AB_DIVISION_RADIO_OPTIONS.map(({ value, label }) => (
+ {
+ const newDivision: AbDivisionValue =
+ rawValue === "unassigned"
+ ? null
+ : (Number(rawValue) as 0 | 1);
+ setTeamAbDivisions((teamAbDivisions) =>
+ teamAbDivisions.map((t) =>
+ t.tournamentTeamId === team.id
+ ? { ...t, abDivision: newDivision }
+ : t,
+ ),
+ );
+ }}
+ >
+ {label}
+
+ ))}
+
+
+
+ );
+ })}
+
+
+
+ Save
+
+
+
+
`${sql.ref("CalendarEvent.name")} like ${pattern} escape '\\'`;
+};
+
export function findResultsByUserId(
userId: number,
{
showHighlightsOnly = false,
limit,
offset,
- }: { showHighlightsOnly?: boolean; limit?: number; offset?: number } = {},
+ tournamentName,
+ }: {
+ showHighlightsOnly?: boolean;
+ limit?: number;
+ offset?: number;
+ tournamentName?: string;
+ } = {},
) {
let calendarEventResultsQuery = baseCalendarEventResultsQuery(userId).select(
({ eb, fn }) => [
@@ -634,6 +648,15 @@ export function findResultsByUserId(
);
}
+ if (tournamentName) {
+ calendarEventResultsQuery = calendarEventResultsQuery.where(
+ tournamentNameLikeExpr(tournamentName),
+ );
+ tournamentResultsQuery = tournamentResultsQuery.where(
+ tournamentNameLikeExpr(tournamentName),
+ );
+ }
+
let query = calendarEventResultsQuery
.unionAll(tournamentResultsQuery)
.orderBy("startTime", "desc")
@@ -652,7 +675,10 @@ export function findResultsByUserId(
export async function countResultsByUserId(
userId: number,
- { showHighlightsOnly = false }: { showHighlightsOnly?: boolean } = {},
+ {
+ showHighlightsOnly = false,
+ tournamentName,
+ }: { showHighlightsOnly?: boolean; tournamentName?: string } = {},
) {
let calendarEventResultsQuery = baseCalendarEventResultsQuery(userId).select(
({ fn }) => [fn.countAll().as("count")],
@@ -675,6 +701,15 @@ export async function countResultsByUserId(
);
}
+ if (tournamentName) {
+ calendarEventResultsQuery = calendarEventResultsQuery.where(
+ tournamentNameLikeExpr(tournamentName),
+ );
+ tournamentResultsQuery = tournamentResultsQuery.where(
+ tournamentNameLikeExpr(tournamentName),
+ );
+ }
+
const [calendarEventResults, tournamentResults] = await Promise.all([
calendarEventResultsQuery.executeTakeFirst(),
tournamentResultsQuery.executeTakeFirst(),
diff --git a/app/features/user-page/actions/u.$identifier.builds.server.ts b/app/features/user-page/actions/u.$identifier.builds.server.ts
index 37729b879..54da58a64 100644
--- a/app/features/user-page/actions/u.$identifier.builds.server.ts
+++ b/app/features/user-page/actions/u.$identifier.builds.server.ts
@@ -26,15 +26,9 @@ export const action: ActionFunction = async ({ request }) => {
switch (data._action) {
case "DELETE_BUILD": {
- const usersBuilds = await BuildRepository.allByUserId(user.id, {
- showPrivate: true,
- });
+ const ownerId = await BuildRepository.ownerIdById(data.buildToDeleteId);
- const buildToDelete = usersBuilds.find(
- (build) => build.id === data.buildToDeleteId,
- );
-
- errorToastIfFalsy(buildToDelete, "Build to delete not found");
+ errorToastIfFalsy(ownerId === user.id, "Build to delete not found");
await BuildRepository.deleteById(data.buildToDeleteId);
diff --git a/app/features/user-page/core/build-sorting.server.test.ts b/app/features/user-page/core/build-sorting.server.test.ts
index 12156fae6..83e8ad44e 100644
--- a/app/features/user-page/core/build-sorting.server.test.ts
+++ b/app/features/user-page/core/build-sorting.server.test.ts
@@ -329,6 +329,41 @@ describe("sortBuilds()", () => {
expect(sortedBuilds[2].id).toBe(1);
});
+
+ it(`sorts ${identifier} with null gear last`, () => {
+ const key = (
+ {
+ HEADGEAR_ID: "headGearSplId",
+ CLOTHES_ID: "clothesGearSplId",
+ SHOES_ID: "shoesGearSplId",
+ } as const
+ )[identifier]!;
+
+ const builds = [
+ mockBuild({
+ id: 1,
+ [key]: null,
+ }),
+ mockBuild({
+ id: 2,
+ [key]: 5,
+ }),
+ mockBuild({
+ id: 3,
+ [key]: 1,
+ }),
+ ];
+
+ const sortedBuilds = sortBuilds({
+ builds,
+ buildSorting: [identifier as any],
+ weaponPool: [],
+ });
+
+ expect(sortedBuilds[0].id).toBe(3);
+ expect(sortedBuilds[1].id).toBe(2);
+ expect(sortedBuilds[2].id).toBe(1);
+ });
}
it("sorts when buildSort not given", () => {
diff --git a/app/features/user-page/core/build-sorting.server.ts b/app/features/user-page/core/build-sorting.server.ts
index b2ee5b8d6..b47880c4a 100644
--- a/app/features/user-page/core/build-sorting.server.ts
+++ b/app/features/user-page/core/build-sorting.server.ts
@@ -28,9 +28,12 @@ export function sortBuilds({
Math.min(...a.weapons.map((wpn) => wpn.weaponSplId)) -
Math.min(...b.weapons.map((wpn) => wpn.weaponSplId)),
UPDATED_AT: (a, b) => b.updatedAt - a.updatedAt,
- HEADGEAR_ID: (a, b) => a.headGearSplId - b.headGearSplId,
- CLOTHES_ID: (a, b) => a.clothesGearSplId - b.clothesGearSplId,
- SHOES_ID: (a, b) => a.shoesGearSplId - b.shoesGearSplId,
+ HEADGEAR_ID: (a, b) =>
+ compareNullableNumbers(a.headGearSplId, b.headGearSplId),
+ CLOTHES_ID: (a, b) =>
+ compareNullableNumbers(a.clothesGearSplId, b.clothesGearSplId),
+ SHOES_ID: (a, b) =>
+ compareNullableNumbers(a.shoesGearSplId, b.shoesGearSplId),
MODE: (a, b) => {
const aLowestModeIdx = modesShort.findIndex((mode) =>
a.modes?.includes(mode),
@@ -104,3 +107,10 @@ export function sortBuilds({
return 0;
});
}
+
+function compareNullableNumbers(a: number | null, b: number | null) {
+ if (a === null && b === null) return 0;
+ if (a === null) return 1;
+ if (b === null) return -1;
+ return a - b;
+}
diff --git a/app/features/user-page/loaders/u.$identifier.builds.new.server.ts b/app/features/user-page/loaders/u.$identifier.builds.new.server.ts
index fc7170648..30edf1315 100644
--- a/app/features/user-page/loaders/u.$identifier.builds.new.server.ts
+++ b/app/features/user-page/loaders/u.$identifier.builds.new.server.ts
@@ -68,13 +68,9 @@ function resolveDefaultValues(
return {
buildToEditId: buildToEdit?.id,
weapons,
- head: buildToEdit?.headGearSplId === -1 ? null : buildToEdit?.headGearSplId,
- clothes:
- buildToEdit?.clothesGearSplId === -1
- ? null
- : buildToEdit?.clothesGearSplId,
- shoes:
- buildToEdit?.shoesGearSplId === -1 ? null : buildToEdit?.shoesGearSplId,
+ head: buildToEdit?.headGearSplId,
+ clothes: buildToEdit?.clothesGearSplId,
+ shoes: buildToEdit?.shoesGearSplId,
abilities,
title: buildToEdit?.title,
description: buildToEdit?.description ?? null,
diff --git a/app/features/user-page/loaders/u.$identifier.builds.server.ts b/app/features/user-page/loaders/u.$identifier.builds.server.ts
index 77c51464a..4c4ea0c97 100644
--- a/app/features/user-page/loaders/u.$identifier.builds.server.ts
+++ b/app/features/user-page/loaders/u.$identifier.builds.server.ts
@@ -1,8 +1,8 @@
import type { LoaderFunctionArgs } from "react-router";
+import * as R from "remeda";
import { getUser } from "~/features/auth/core/user.server";
import * as BuildRepository from "~/features/builds/BuildRepository.server";
import * as UserRepository from "~/features/user-page/UserRepository.server";
-import type { MainWeaponId } from "~/modules/in-game-lists/types";
import type { SerializeFrom } from "~/utils/remix";
import { notFoundIfFalsy, privatelyCachedJson } from "~/utils/remix.server";
import { sortBuilds } from "../core/build-sorting.server";
@@ -37,19 +37,9 @@ export const loader = async ({ params }: LoaderFunctionArgs) => {
return privatelyCachedJson({
buildSorting: user.buildSorting,
builds: sortedBuilds,
- weaponCounts: calculateWeaponCounts(),
+ weaponCounts: R.countBy(
+ builds.flatMap((build) => build.weapons),
+ (weapon) => weapon.weaponSplId,
+ ),
});
-
- function calculateWeaponCounts() {
- return builds.reduce(
- (acc, build) => {
- for (const weapon of build.weapons) {
- acc[weapon.weaponSplId] = (acc[weapon.weaponSplId] ?? 0) + 1;
- }
-
- return acc;
- },
- {} as Record,
- );
- }
};
diff --git a/app/features/user-page/loaders/u.$identifier.results.server.ts b/app/features/user-page/loaders/u.$identifier.results.server.ts
index 7d15bf425..5be3ea471 100644
--- a/app/features/user-page/loaders/u.$identifier.results.server.ts
+++ b/app/features/user-page/loaders/u.$identifier.results.server.ts
@@ -1,9 +1,13 @@
import type { LoaderFunctionArgs } from "react-router";
import { redirect } from "react-router";
+import { getUser } from "~/features/auth/core/user.server";
import * as UserRepository from "~/features/user-page/UserRepository.server";
import type { SerializeFrom } from "~/utils/remix";
import { notFoundIfFalsy, parseSafeSearchParams } from "~/utils/remix.server";
-import { RESULTS_PER_PAGE } from "../user-page-constants";
+import {
+ HIGHLIGHTS_RESULTS_MAX,
+ RESULTS_PER_PAGE,
+} from "../user-page-constants";
import { userResultsPageSearchParamsSchema } from "../user-page-schemas";
export type UserResultsLoaderData = SerializeFrom;
@@ -34,15 +38,23 @@ export const loader = async ({ params, request }: LoaderFunctionArgs) => {
}
const page = parsedSearchParams.success ? parsedSearchParams.data.page : 1;
+ const tournamentName =
+ !isChoosingHighlights && getUser() && parsedSearchParams.success
+ ? parsedSearchParams.data.tournament
+ : undefined;
const [results, totalCount] = await Promise.all([
UserRepository.findResultsByUserId(userId, {
showHighlightsOnly,
+ tournamentName,
...(isChoosingHighlights
- ? {}
+ ? { limit: HIGHLIGHTS_RESULTS_MAX }
: { limit: RESULTS_PER_PAGE, offset: (page - 1) * RESULTS_PER_PAGE }),
}),
- UserRepository.countResultsByUserId(userId, { showHighlightsOnly }),
+ UserRepository.countResultsByUserId(userId, {
+ showHighlightsOnly,
+ tournamentName,
+ }),
]);
const maxPage = Math.ceil(totalCount / RESULTS_PER_PAGE);
@@ -72,6 +84,6 @@ function redirectIfPageOutOfBounds({
const url = new URL(request.url);
const searchParams = new URLSearchParams(url.searchParams);
- searchParams.set("page", String(maxPage));
+ searchParams.set("page", String(Math.max(maxPage, 1)));
throw redirect(`${url.pathname}?${searchParams.toString()}`);
}
diff --git a/app/features/user-page/routes/u.$identifier.results.tsx b/app/features/user-page/routes/u.$identifier.results.tsx
index e6be55a7e..fe0baafcf 100644
--- a/app/features/user-page/routes/u.$identifier.results.tsx
+++ b/app/features/user-page/routes/u.$identifier.results.tsx
@@ -1,6 +1,10 @@
+import { Search } from "lucide-react";
+import * as React from "react";
import { useTranslation } from "react-i18next";
import { useLoaderData, useMatches, useSearchParams } from "react-router";
+import { useDebounce } from "react-use";
import { LinkButton } from "~/components/elements/Button";
+import { Input } from "~/components/Input";
import { Pagination } from "~/components/Pagination";
import { useUser } from "~/features/auth/core/user";
import { UserResultsTable } from "~/features/user-page/components/UserResultsTable";
@@ -10,6 +14,7 @@ import { SendouButton } from "../../../components/elements/Button";
import { SubPageHeader } from "../components/SubPageHeader";
import { loader } from "../loaders/u.$identifier.results.server";
import type { UserPageLoaderData } from "../loaders/u.$identifier.server";
+import styles from "../user-page.module.css";
export { loader };
@@ -25,6 +30,34 @@ export default function UserResultsPage() {
const [searchParams, setSearchParams] = useSearchParams();
const showAll = searchParams.get("all") === "true";
+ const urlTournamentQuery = searchParams.get("tournament") ?? "";
+ const [tournamentQuery, setTournamentQuery] =
+ React.useState(urlTournamentQuery);
+ const [prevUrlTournamentQuery, setPrevUrlTournamentQuery] =
+ React.useState(urlTournamentQuery);
+
+ if (urlTournamentQuery !== prevUrlTournamentQuery) {
+ setPrevUrlTournamentQuery(urlTournamentQuery);
+ setTournamentQuery(urlTournamentQuery);
+ }
+
+ useDebounce(
+ () => {
+ if (urlTournamentQuery === tournamentQuery) return;
+ setSearchParams((params) => {
+ if (tournamentQuery) {
+ params.set("tournament", tournamentQuery);
+ } else {
+ params.delete("tournament");
+ }
+ params.delete("page");
+ return params;
+ });
+ },
+ 300,
+ [tournamentQuery],
+ );
+
const setPage = (page: number) => {
setSearchParams((params) => {
params.set("page", String(page));
@@ -44,15 +77,23 @@ export default function UserResultsPage() {
? t("results.title")
: t("results.highlights")}
- {user?.id === layoutData.user.id ? (
-
- {t("results.highlights.choose")}
-
- ) : null}
+
+ {user ? (
+
+ {t("results.highlights.choose")}
+
+ ) : null}
+
(
return [...distribution, ...symmetry];
}
+/**
+ * Makes a list of rounds containing the matches of a bipartite (A/B divisions) round-robin group.
+ *
+ * Every A team plays every B team exactly once; there are no A-vs-A or B-vs-B matches.
+ * Round 1 is cross-seeded (strongest A vs weakest B), and B is rotated cyclically downward
+ * in each subsequent round.
+ *
+ * When the divisions have different sizes, the shorter side is padded with bye slots so the
+ * rotation still works. Those bye pairings are filtered out of the output, so each round has
+ * exactly `min(|A|, |B|)` real matches and the total is `|A| * |B|`.
+ *
+ * @param divisionA Participants in division A, ordered by seed.
+ * @param divisionB Participants in division B, ordered by seed.
+ */
+export function makeAbDivisionRoundRobinMatches(
+ divisionA: T[],
+ divisionB: T[],
+): [T, T][][] {
+ const n = Math.max(divisionA.length, divisionB.length);
+ const paddedA: (T | null)[] = [
+ ...divisionA,
+ ...Array(n - divisionA.length).fill(null),
+ ];
+ const paddedB: (T | null)[] = [
+ ...divisionB,
+ ...Array(n - divisionB.length).fill(null),
+ ];
+ const rounds: [T, T][][] = [];
+
+ for (let roundIdx = 0; roundIdx < n; roundIdx++) {
+ const matches: [T, T][] = [];
+
+ for (let i = 0; i < n; i++) {
+ const bIdx = (((n - 1 - i - roundIdx) % n) + n) % n;
+ const a = paddedA[i];
+ const b = paddedB[bIdx];
+ if (a === null || b === null) continue;
+ matches.push([a, b]);
+ }
+
+ rounds.push(matches);
+ }
+
+ return rounds;
+}
+
+/**
+ * Distributes A/B division participants into groups such that each group has an
+ * equal number of A and B participants.
+ *
+ * The snake ordering used by `groups.seed_optimized` is applied independently to
+ * each pool, so that relative seed order within each pool is preserved within
+ * every group.
+ *
+ * @param divisionA Participants in division A, ordered by seed.
+ * @param divisionB Participants in division B, ordered by seed.
+ * @param groupCount Number of groups to distribute into.
+ */
+export function makeAbDivisionGroups(
+ divisionA: T[],
+ divisionB: T[],
+ groupCount: number,
+): { a: T[]; b: T[] }[] {
+ if (groupCount <= 0) throw Error("Group count must be strictly positive.");
+
+ if (divisionA.length !== divisionB.length) {
+ if (groupCount !== 1)
+ throw Error(
+ "Uneven A/B divisions are only supported with a single group.",
+ );
+
+ return [{ a: divisionA, b: divisionB }];
+ }
+
+ if (divisionA.length % groupCount !== 0)
+ throw Error("Pool size must be divisible by group count.");
+
+ const aOrdered = ordering["groups.seed_optimized"](divisionA, groupCount);
+ const bOrdered = ordering["groups.seed_optimized"](divisionB, groupCount);
+
+ const perPoolGroupSize = divisionA.length / groupCount;
+ const groups: { a: T[]; b: T[] }[] = [];
+
+ for (let i = 0; i < groupCount; i++) {
+ groups.push({
+ a: aOrdered.slice(i * perPoolGroupSize, (i + 1) * perPoolGroupSize),
+ b: bOrdered.slice(i * perPoolGroupSize, (i + 1) * perPoolGroupSize),
+ });
+ }
+
+ return groups;
+}
+
/**
* Distributes participants in rounds for a round-robin group.
*
@@ -143,6 +236,57 @@ export function assertRoundRobin(
}
}
+/**
+ * A helper to assert our generated bipartite round-robin is correct.
+ *
+ * @param divisionA Seeds in division A (ordered by seed).
+ * @param divisionB Seeds in division B (ordered by seed).
+ * @param output The resulting rounds of matches.
+ */
+export function assertAbDivisionRoundRobin(
+ divisionA: number[],
+ divisionB: number[],
+ output: [number, number][][],
+): void {
+ const roundCount = Math.max(divisionA.length, divisionB.length);
+ const matchesPerRound = Math.min(divisionA.length, divisionB.length);
+
+ if (output.length !== roundCount) throw Error("Round count is wrong");
+ if (!output.every((round) => round.length === matchesPerRound))
+ throw Error("Not every round has the good number of matches");
+
+ const aSet = new Set(divisionA);
+ const bSet = new Set(divisionB);
+ const seenPairings = new Set();
+
+ for (const round of output) {
+ const playingInRound = new Set();
+
+ for (const match of round) {
+ if (match.length !== 2) throw Error("One match is not a pair");
+
+ const [a, b] = match;
+
+ if (!aSet.has(a)) throw Error(`${a} is not a division A participant`);
+ if (!bSet.has(b)) throw Error(`${b} is not a division B participant`);
+
+ if (playingInRound.has(a)) throw Error("This team is already playing");
+ playingInRound.add(a);
+
+ if (playingInRound.has(b)) throw Error("This team is already playing");
+ playingInRound.add(b);
+
+ const pairingKey = `${a}-${b}`;
+ if (seenPairings.has(pairingKey))
+ throw Error("The teams have already been paired");
+ seenPairings.add(pairingKey);
+ }
+ }
+
+ if (seenPairings.size !== divisionA.length * divisionB.length)
+ throw Error("Not every A vs B pairing was generated");
+}
+
/**
* Distributes elements in groups of equal size.
*
diff --git a/app/modules/brackets-manager/index.ts b/app/modules/brackets-manager/index.ts
index 3a0fd160b..3cc3935c8 100644
--- a/app/modules/brackets-manager/index.ts
+++ b/app/modules/brackets-manager/index.ts
@@ -1,30 +1,11 @@
import { BracketsManager } from "./manager";
-import type {
- CrudInterface,
- Database,
- Duel,
- OmitId,
- OrderingMap,
- ParticipantSlot,
- Scores,
- Side,
- StandardBracketResults,
- Storage,
- Table,
-} from "./types";
+import type { CrudInterface, Database, OmitId, Table } from "./types";
export {
BracketsManager,
type CrudInterface,
type Database,
- type Duel,
type OmitId,
- type OrderingMap,
- type ParticipantSlot,
- type Scores,
- type Side,
- type StandardBracketResults,
- type Storage,
type Table,
};
diff --git a/app/modules/brackets-manager/test/helpers.test.ts b/app/modules/brackets-manager/test/helpers.test.ts
index d119d0832..9a8de5d86 100644
--- a/app/modules/brackets-manager/test/helpers.test.ts
+++ b/app/modules/brackets-manager/test/helpers.test.ts
@@ -1,7 +1,10 @@
import { describe, expect, test } from "vitest";
import {
+ assertAbDivisionRoundRobin,
assertRoundRobin,
balanceByes,
+ makeAbDivisionGroups,
+ makeAbDivisionRoundRobinMatches,
makeGroups,
makeRoundRobinMatches,
} from "../helpers";
@@ -35,6 +38,256 @@ describe("Round-robin groups", () => {
});
});
+describe("A/B divisions round-robin groups", () => {
+ test("should pair every A with every B exactly once for N=2..6", () => {
+ for (const n of [2, 3, 4, 5, 6]) {
+ const divisionA = Array.from({ length: n }, (_, i) => i + 1);
+ const divisionB = Array.from({ length: n }, (_, i) => i + 1 + n);
+
+ assertAbDivisionRoundRobin(
+ divisionA,
+ divisionB,
+ makeAbDivisionRoundRobinMatches(divisionA, divisionB),
+ );
+ }
+ });
+
+ test("should produce N rounds and N^2 matches total", () => {
+ for (const n of [2, 3, 4, 5, 6]) {
+ const divisionA = Array.from({ length: n }, (_, i) => i + 1);
+ const divisionB = Array.from({ length: n }, (_, i) => i + 1 + n);
+
+ const rounds = makeAbDivisionRoundRobinMatches(divisionA, divisionB);
+
+ expect(rounds).toHaveLength(n);
+ expect(rounds.flat()).toHaveLength(n * n);
+ expect(rounds.every((round) => round.length === n)).toBe(true);
+ }
+ });
+
+ test("round 1 is cross-seeded (A[i] vs B[N-1-i])", () => {
+ for (const n of [2, 3, 4, 5, 6]) {
+ const divisionA = Array.from({ length: n }, (_, i) => i + 1);
+ const divisionB = Array.from({ length: n }, (_, i) => i + 1 + n);
+
+ const [firstRound] = makeAbDivisionRoundRobinMatches(
+ divisionA,
+ divisionB,
+ );
+
+ const expected = divisionA.map<[number, number]>((a, i) => [
+ a,
+ divisionB[n - 1 - i],
+ ]);
+ expect(firstRound).toEqual(expected);
+ }
+ });
+
+ test("matches the spec example for N=6", () => {
+ const divisionA = [1, 2, 3, 4, 5, 6];
+ const divisionB = [11, 12, 13, 14, 15, 16];
+
+ const rounds = makeAbDivisionRoundRobinMatches(divisionA, divisionB);
+
+ expect(rounds[0]).toEqual([
+ [1, 16],
+ [2, 15],
+ [3, 14],
+ [4, 13],
+ [5, 12],
+ [6, 11],
+ ]);
+ expect(rounds[1]).toEqual([
+ [1, 15],
+ [2, 14],
+ [3, 13],
+ [4, 12],
+ [5, 11],
+ [6, 16],
+ ]);
+ expect(rounds[2]).toEqual([
+ [1, 14],
+ [2, 13],
+ [3, 12],
+ [4, 11],
+ [5, 16],
+ [6, 15],
+ ]);
+ });
+
+ test("supports uneven divisions where |A| = |B| + 1", () => {
+ const divisionA = [1, 2, 3, 4, 5, 6];
+ const divisionB = [11, 12, 13, 14, 15];
+
+ const rounds = makeAbDivisionRoundRobinMatches(divisionA, divisionB);
+
+ assertAbDivisionRoundRobin(divisionA, divisionB, rounds);
+ expect(rounds).toHaveLength(6);
+ expect(rounds.flat()).toHaveLength(5 * 6);
+ expect(rounds.every((round) => round.length === 5)).toBe(true);
+
+ const byeCountPerA = new Map(divisionA.map((a) => [a, 0]));
+ for (const round of rounds) {
+ const playingA = new Set(round.map(([a]) => a));
+ for (const a of divisionA) {
+ if (!playingA.has(a)) byeCountPerA.set(a, byeCountPerA.get(a)! + 1);
+ }
+ }
+ expect([...byeCountPerA.values()]).toEqual([1, 1, 1, 1, 1, 1]);
+ });
+
+ test("supports uneven divisions where |B| = |A| + 1", () => {
+ const divisionA = [1, 2, 3, 4, 5];
+ const divisionB = [11, 12, 13, 14, 15, 16];
+
+ const rounds = makeAbDivisionRoundRobinMatches(divisionA, divisionB);
+
+ assertAbDivisionRoundRobin(divisionA, divisionB, rounds);
+ expect(rounds).toHaveLength(6);
+ expect(rounds.flat()).toHaveLength(5 * 6);
+ expect(rounds.every((round) => round.length === 5)).toBe(true);
+
+ const byeCountPerB = new Map(divisionB.map((b) => [b, 0]));
+ for (const round of rounds) {
+ const playingB = new Set(round.map(([, b]) => b));
+ for (const b of divisionB) {
+ if (!playingB.has(b)) byeCountPerB.set(b, byeCountPerB.get(b)! + 1);
+ }
+ }
+ expect([...byeCountPerB.values()]).toEqual([1, 1, 1, 1, 1, 1]);
+ });
+
+ test("handles non-contiguous seed identifiers in each pool", () => {
+ const divisionA = [1, 4, 5];
+ const divisionB = [9, 10, 12];
+
+ const rounds = makeAbDivisionRoundRobinMatches(divisionA, divisionB);
+
+ assertAbDivisionRoundRobin(divisionA, divisionB, rounds);
+ expect(rounds[0]).toEqual([
+ [1, 12],
+ [4, 10],
+ [5, 9],
+ ]);
+ });
+});
+
+describe("A/B division group distribution", () => {
+ const CASES: ReadonlyArray = [
+ [6, 1],
+ [6, 2],
+ [6, 3],
+ [6, 6],
+ [4, 1],
+ [4, 2],
+ [4, 4],
+ [3, 1],
+ [3, 3],
+ [8, 2],
+ [8, 4],
+ ];
+
+ test("places all teams with equal A/B per group for supported sizes", () => {
+ for (const [poolSize, groupCount] of CASES) {
+ const divisionA = Array.from({ length: poolSize }, (_, i) => i + 1);
+ const divisionB = Array.from(
+ { length: poolSize },
+ (_, i) => i + 1 + poolSize,
+ );
+
+ const groups = makeAbDivisionGroups(divisionA, divisionB, groupCount);
+
+ expect(groups).toHaveLength(groupCount);
+
+ const perGroupSize = poolSize / groupCount;
+ for (const group of groups) {
+ expect(group.a).toHaveLength(perGroupSize);
+ expect(group.b).toHaveLength(perGroupSize);
+ }
+
+ const flatA = groups.flatMap((g) => g.a).sort((x, y) => x - y);
+ const flatB = groups.flatMap((g) => g.b).sort((x, y) => x - y);
+ expect(flatA).toEqual(divisionA);
+ expect(flatB).toEqual(divisionB);
+ }
+ });
+
+ test("preserves ascending seed order within each group's A and B pools", () => {
+ for (const [poolSize, groupCount] of CASES) {
+ const divisionA = Array.from({ length: poolSize }, (_, i) => i + 1);
+ const divisionB = Array.from(
+ { length: poolSize },
+ (_, i) => i + 1 + poolSize,
+ );
+
+ const groups = makeAbDivisionGroups(divisionA, divisionB, groupCount);
+
+ for (const group of groups) {
+ expect(group.a).toEqual([...group.a].sort((x, y) => x - y));
+ expect(group.b).toEqual([...group.b].sort((x, y) => x - y));
+ }
+ }
+ });
+
+ test("is deterministic for identical input", () => {
+ const divisionA = [1, 2, 3, 4, 5, 6];
+ const divisionB = [7, 8, 9, 10, 11, 12];
+
+ const first = makeAbDivisionGroups(divisionA, divisionB, 2);
+ const second = makeAbDivisionGroups(divisionA, divisionB, 2);
+
+ expect(first).toEqual(second);
+ });
+
+ test("matches the expected snake distribution for 12 teams, 2 groups", () => {
+ const divisionA = [1, 2, 3, 4, 5, 6];
+ const divisionB = [7, 8, 9, 10, 11, 12];
+
+ expect(makeAbDivisionGroups(divisionA, divisionB, 2)).toEqual([
+ { a: [1, 4, 5], b: [7, 10, 11] },
+ { a: [2, 3, 6], b: [8, 9, 12] },
+ ]);
+ });
+
+ test("matches the expected snake distribution for 12 teams, 3 groups", () => {
+ const divisionA = [1, 2, 3, 4, 5, 6];
+ const divisionB = [7, 8, 9, 10, 11, 12];
+
+ expect(makeAbDivisionGroups(divisionA, divisionB, 3)).toEqual([
+ { a: [1, 6], b: [7, 12] },
+ { a: [2, 5], b: [8, 11] },
+ { a: [3, 4], b: [9, 10] },
+ ]);
+ });
+
+ test("single group contains all teams", () => {
+ const divisionA = [1, 2, 3, 4];
+ const divisionB = [5, 6, 7, 8];
+
+ expect(makeAbDivisionGroups(divisionA, divisionB, 1)).toEqual([
+ { a: divisionA, b: divisionB },
+ ]);
+ });
+
+ test("allows uneven pools with a single group", () => {
+ expect(makeAbDivisionGroups([1, 2, 3], [4, 5], 1)).toEqual([
+ { a: [1, 2, 3], b: [4, 5] },
+ ]);
+ });
+
+ test("throws when pools have different sizes and multiple groups", () => {
+ expect(() => makeAbDivisionGroups([1, 2, 3], [4, 5], 2)).toThrow();
+ });
+
+ test("throws when pool size is not divisible by group count", () => {
+ expect(() => makeAbDivisionGroups([1, 2, 3], [4, 5, 6], 2)).toThrow();
+ });
+
+ test("throws when group count is not positive", () => {
+ expect(() => makeAbDivisionGroups([1], [2], 0)).toThrow();
+ });
+});
+
describe("Seed ordering methods", () => {
test("should place 2 participants with inner-outer method", () => {
const teams = [1, 2];
diff --git a/app/modules/brackets-manager/test/round-robin.test.ts b/app/modules/brackets-manager/test/round-robin.test.ts
index f27e52938..879e56886 100644
--- a/app/modules/brackets-manager/test/round-robin.test.ts
+++ b/app/modules/brackets-manager/test/round-robin.test.ts
@@ -164,6 +164,98 @@ describe("Create a round-robin stage", () => {
}),
).toThrow("You must provide a strictly positive group count.");
});
+
+ test("creates an A/B divisions round-robin where every A team plays every B team once", () => {
+ const seeding = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12];
+ // alternate A (0) / B (1) so that seed order 1..12 gives A=[1,3,5,7,9,11], B=[2,4,6,8,10,12]
+ const abDivisions = seeding.map((_, i) => (i % 2 === 0 ? 0 : 1));
+
+ manager.create({
+ name: "AB Example",
+ tournamentId: 0,
+ type: "round_robin",
+ seeding,
+ abDivisions: abDivisions as (0 | 1)[],
+ settings: {
+ groupCount: 1,
+ hasAbDivisions: true,
+ seedOrdering: ["groups.seed_optimized"],
+ },
+ });
+
+ expect(storage.select("group")!.length).toBe(1);
+ expect(storage.select("round")!.length).toBe(6);
+ expect(storage.select("match")!.length).toBe(36);
+
+ const divisionAIds = new Set([1, 3, 5, 7, 9, 11]);
+ const divisionBIds = new Set([2, 4, 6, 8, 10, 12]);
+ const pairings = new Set();
+
+ for (const match of storage.select("match")!) {
+ const aId: number = match.opponent1.id;
+ const bId: number = match.opponent2.id;
+
+ expect(divisionAIds.has(aId)).toBe(true);
+ expect(divisionBIds.has(bId)).toBe(true);
+
+ const key = `${aId}-${bId}`;
+ expect(pairings.has(key)).toBe(false);
+ pairings.add(key);
+ }
+
+ expect(pairings.size).toBe(36);
+ });
+
+ test("throws when A/B divisions are requested but abDivisions is missing", () => {
+ expect(() =>
+ manager.create({
+ name: "Missing AB",
+ tournamentId: 0,
+ type: "round_robin",
+ seeding: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12],
+ settings: {
+ groupCount: 1,
+ hasAbDivisions: true,
+ },
+ }),
+ ).toThrow("abDivisions must be provided when hasAbDivisions is enabled.");
+ });
+
+ test("creates an A/B divisions round-robin with uneven (±1) divisions and a single group", () => {
+ const seeding = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
+ manager.create({
+ name: "Uneven AB",
+ tournamentId: 0,
+ type: "round_robin",
+ seeding,
+ abDivisions: [0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0],
+ settings: {
+ groupCount: 1,
+ hasAbDivisions: true,
+ seedOrdering: ["groups.seed_optimized"],
+ },
+ });
+
+ expect(storage.select("group")!.length).toBe(1);
+ expect(storage.select("round")!.length).toBe(6);
+ expect(storage.select("match")!.length).toBe(30);
+ });
+
+ test("throws when A/B divisions are uneven with multiple groups", () => {
+ expect(() =>
+ manager.create({
+ name: "Uneven AB multi-group",
+ tournamentId: 0,
+ type: "round_robin",
+ seeding: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
+ abDivisions: [0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0],
+ settings: {
+ groupCount: 2,
+ hasAbDivisions: true,
+ },
+ }),
+ ).toThrow("Uneven A/B divisions are only supported with a single group.");
+ });
});
describe("Update scores in a round-robin stage", () => {
diff --git a/app/modules/brackets-manager/types.ts b/app/modules/brackets-manager/types.ts
index 29700c2f7..39ced56ba 100644
--- a/app/modules/brackets-manager/types.ts
+++ b/app/modules/brackets-manager/types.ts
@@ -44,11 +44,6 @@ export type Duel = [ParticipantSlot, ParticipantSlot];
*/
export type Side = "opponent1" | "opponent2";
-/**
- * The cumulated scores of the opponents in a match's child games.
- */
-export type Scores = { opponent1: number; opponent2: number };
-
/**
* Positional information about a round.
*/
diff --git a/app/modules/brackets-model/input.ts b/app/modules/brackets-model/input.ts
index 2a2e3745f..6651eff3d 100644
--- a/app/modules/brackets-model/input.ts
+++ b/app/modules/brackets-model/input.ts
@@ -43,6 +43,12 @@ export interface InputStage {
/** Contains participants or `null` for BYEs. */
seeding?: Seeding;
+ /**
+ * A/B division assignment parallel to `seeding`. `0` = A, `1` = B.
+ * Required when `settings.hasAbDivisions` is `true`.
+ */
+ abDivisions?: (0 | 1)[];
+
/** Contains optional settings specific to each stage type. */
settings?: StageSettings;
}
@@ -90,6 +96,13 @@ export interface StageSettings {
*/
roundRobinMode?: RoundRobinMode;
+ /**
+ * Whether to generate a bipartite round-robin where teams are split into two
+ * A/B divisions and every match pairs one A team with one B team.
+ * Only valid on round-robin stages.
+ */
+ hasAbDivisions?: boolean;
+
/**
* A list of seeds per group for a round-robin stage to be manually ordered.
*
diff --git a/app/routines/setOldGroupsAsInactive.ts b/app/routines/setOldGroupsAsInactive.ts
index 6389ff9c4..9f6609155 100644
--- a/app/routines/setOldGroupsAsInactive.ts
+++ b/app/routines/setOldGroupsAsInactive.ts
@@ -1,3 +1,4 @@
+import { refreshSendouQInstance } from "~/features/sendouq/core/SendouQ.server";
import * as SQGroupRepository from "~/features/sendouq/SQGroupRepository.server";
import { logger } from "../utils/logger";
import { Routine } from "./routine.server";
@@ -6,6 +7,7 @@ export const SetOldGroupsAsInactiveRoutine = new Routine({
name: "SetOldGroupsAsInactive",
func: async () => {
const { numUpdatedRows } = await SQGroupRepository.setOldGroupsAsInactive();
+ await refreshSendouQInstance();
logger.info(`Set ${numUpdatedRows} as inactive`);
},
});
diff --git a/app/styles/common.css b/app/styles/common.css
index 4a5a6aa9d..154c013e1 100644
--- a/app/styles/common.css
+++ b/app/styles/common.css
@@ -461,6 +461,7 @@
height: 100%;
border: none;
background-color: var(--color-bg-higher);
+ color: var(--color-text-high);
white-space: nowrap;
margin-right: var(--s-2);
}
diff --git a/app/styles/utils.css b/app/styles/utils.css
index 598e79955..f64367cf3 100644
--- a/app/styles/utils.css
+++ b/app/styles/utils.css
@@ -85,6 +85,7 @@
.underline {
text-decoration: underline;
+ text-decoration-thickness: 2px;
}
.line-through {
diff --git a/app/utils/errors.ts b/app/utils/errors.ts
index 61ae95a3b..d42542ec2 100644
--- a/app/utils/errors.ts
+++ b/app/utils/errors.ts
@@ -4,3 +4,10 @@ export class LimitReachedError extends Error {
this.name = "LimitReachedError";
}
}
+
+export class ConcurrentModificationError extends Error {
+ constructor(message: string) {
+ super(message);
+ this.name = "ConcurrentModificationError";
+ }
+}
diff --git a/app/utils/remix.server.ts b/app/utils/remix.server.ts
index cf52aa0fc..58afdcaa1 100644
--- a/app/utils/remix.server.ts
+++ b/app/utils/remix.server.ts
@@ -302,7 +302,7 @@ export function privatelyCachedJson(dataValue: T) {
});
}
-const MAX_FILE_SIZE_BYTES = 5 * 1024 * 1024;
+const DEFAULT_MAX_FILE_SIZE_BYTES = 2 * 1024 * 1024;
type FileUploadHandler = (
fileUpload: FileUpload,
@@ -323,6 +323,11 @@ export async function safeParseMultipartFormData(
optionsOrHandler?: ParseFormDataOptions | FileUploadHandler,
uploadHandler?: FileUploadHandler,
): Promise {
+ const maxFileSize =
+ typeof optionsOrHandler === "object" && optionsOrHandler?.maxFileSize
+ ? optionsOrHandler.maxFileSize
+ : DEFAULT_MAX_FILE_SIZE_BYTES;
+
try {
if (typeof optionsOrHandler === "function") {
return await parseMultipartFormData(request, optionsOrHandler);
@@ -335,11 +340,12 @@ export async function safeParseMultipartFormData(
} catch (err) {
if (
err instanceof Error &&
- err.cause instanceof Error &&
- err.cause.name === "MaxFileSizeExceededError"
+ (err.name === "MaxFileSizeExceededError" ||
+ (err.cause instanceof Error &&
+ err.cause.name === "MaxFileSizeExceededError"))
) {
throw errorToastRedirect(
- `File size exceeds maximum allowed size of ${MAX_FILE_SIZE_BYTES / 1024 / 1024}MB`,
+ `File size exceeds maximum allowed size of ${maxFileSize / 1024 / 1024}MB`,
);
}
throw err;
diff --git a/content/articles/gamers-for-giving-2026.md b/content/articles/gamers-for-giving-2026.md
new file mode 100644
index 000000000..2564bc565
--- /dev/null
+++ b/content/articles/gamers-for-giving-2026.md
@@ -0,0 +1,119 @@
+---
+title: "Gamers for Giving 2026"
+date: 2026-04-09
+author:
+ - name: YELLOW
+ link: https://sendou.ink/u/great-hero-yellow
+---
+
+#### *Splatoon fans coming together to bring the joy of gaming to those in need*
+
+
-
-
+
+