Files
lolympus-tournament-support/apps/web/src/components/competition/double-elimination-bracket-layout.ts
T

1206 lines
36 KiB
TypeScript

import type {
BracketRoundView,
DoubleEliminationCompetitionProjection,
SeriesConnectorView,
SeriesId,
SeriesSlot,
SeriesStageType,
} from "@lolympus/contracts";
import { SERIES_SCORE_CARD_GEOMETRY } from "./series-score-card-geometry.ts";
type BracketStage = "upper" | "lower" | "grand-final" | "reset-final";
export type BracketLane = "upper" | "lower" | "final";
export type BracketConnectorKind = "winner" | "loser" | "reset";
export const DOUBLE_ELIMINATION_BRACKET_GEOMETRY = {
boardPadding: 12,
columnWidth: 228,
columnGap: 40,
// Matches the widest focused connector underlay so parallel routes stay legible.
connectorRailClearance: 5,
cardBorderWidth: SERIES_SCORE_CARD_GEOMETRY.borderWidth,
cardHeight: SERIES_SCORE_CARD_GEOMETRY.height,
cardHeaderHeight: SERIES_SCORE_CARD_GEOMETRY.headerHeight,
cardEntryHeight: SERIES_SCORE_CARD_GEOMETRY.entryHeight,
cardGap: 20,
upperTop: 64,
laneGap: 152,
} as const;
export interface BracketNodeLayout {
seriesId: SeriesId;
label: string;
accessibleLabel: string;
stage: BracketStage;
roundNumber: number;
lane: BracketLane;
column: number;
x: number;
y: number;
width: number;
height: number;
}
export interface BracketConnectorLayout {
fromSeriesId: SeriesId;
select: SeriesConnectorView["from"]["select"];
toSeriesId: SeriesId;
toSlot: SeriesSlot;
kind: BracketConnectorKind;
sourceX: number;
sourceY: number;
verticalX: number;
targetX: number;
targetY: number;
path: string;
label: string;
accessibleLabel: string;
}
export interface DoubleEliminationBracketConfiguration {
teamCount: 4 | 8;
resetFinalEnabled: boolean;
}
export interface BracketRoundLayout {
stage: BracketStage;
roundNumber: number;
label: string;
accessibleLabel: string;
lane: BracketLane;
column: number;
x: number;
labelY: number;
seriesIds: SeriesId[];
}
export interface MobileBracketGroup {
stage: BracketStage;
roundNumber: number;
label: string;
accessibleLabel: string;
seriesIds: SeriesId[];
}
export interface DoubleEliminationBracketLayout {
width: number;
height: number;
columnCount: number;
upperLane: { top: number; height: number };
lowerLane: { top: number; height: number };
finalCenterY: number;
nodes: BracketNodeLayout[];
rounds: BracketRoundLayout[];
connectors: BracketConnectorLayout[];
mobileGroups: MobileBracketGroup[];
}
interface ValidatedGraph {
seriesById: Map<SeriesId, DoubleEliminationCompetitionProjection["series"][number]>;
roundBySeriesId: Map<SeriesId, NormalizedRound>;
rounds: NormalizedRound[];
rankBySeriesId: Map<SeriesId, number>;
}
interface NormalizedRound {
stage: BracketStage;
roundNumber: number;
label: string;
accessibleLabel: string;
seriesIds: SeriesId[];
}
interface ConnectorRoute {
connector: SeriesConnectorView;
key: string;
kind: BracketConnectorKind;
targetColumn: number;
targetNodeY: number;
sourceX: number;
sourceY: number;
targetX: number;
targetY: number;
}
interface SeparateWinnerRailChoice {
verticalXs: [number, number];
crossings: number;
distanceFromBaseline: number;
distanceFromCenter: number;
}
type OrthogonalSegment =
| { orientation: "horizontal"; fixed: number; start: number; end: number }
| { orientation: "vertical"; fixed: number; start: number; end: number };
const STAGE_ORDER: Record<BracketStage, number> = {
upper: 0,
lower: 1,
"grand-final": 2,
"reset-final": 3,
};
const CONNECTOR_SELECTION_ORDER: Record<
SeriesConnectorView["from"]["select"],
number
> = {
winner: 0,
loser: 1,
"slot-a": 2,
"slot-b": 3,
};
// A focused 5px underlay extends 2.5px from its centerline.
const CONNECTOR_RAIL_EDGE_INSET = 3;
export function createDoubleEliminationBracketLayout(
projection: DoubleEliminationCompetitionProjection,
configuration: DoubleEliminationBracketConfiguration,
): DoubleEliminationBracketLayout | null {
const graph = validateGraph(projection, configuration);
if (!graph) return null;
const geometry = DOUBLE_ELIMINATION_BRACKET_GEOMETRY;
const upperRounds = graph.rounds.filter(({ stage }) => stage === "upper");
const lowerRounds = graph.rounds.filter(({ stage }) => stage === "lower");
const upperHeight = laneHeight(upperRounds);
const lowerHeight = laneHeight(lowerRounds);
const upperLane = { top: geometry.upperTop, height: upperHeight };
const lowerLane = {
top: upperLane.top + upperLane.height + geometry.laneGap,
height: lowerHeight,
};
const finalCenterY = upperLane.top + upperLane.height + geometry.laneGap / 2;
const columnCount =
Math.max(...graph.rankBySeriesId.values(), 0) + 1;
const width =
geometry.boardPadding * 2 +
columnCount * geometry.columnWidth +
Math.max(0, columnCount - 1) * geometry.columnGap;
const height = lowerLane.top + lowerLane.height + geometry.boardPadding;
const nodes = buildNodes(graph, upperLane, lowerLane, finalCenterY);
const nodeById = new Map(nodes.map((node) => [node.seriesId, node]));
const connectors = buildConnectors(projection, graph, nodeById);
if (!connectors) return null;
return {
width,
height,
columnCount,
upperLane,
lowerLane,
finalCenterY,
nodes,
rounds: buildRoundLayouts(graph, nodeById, upperLane, lowerLane),
connectors,
mobileGroups: graph.rounds.map((round) => ({ ...round })),
};
}
export function bracketRoundLabel(
stage: SeriesStageType,
roundNumber?: number,
): string {
return formatBracketRoundLabel(stage, roundNumber, "R");
}
export function bracketRoundAccessibleLabel(
stage: SeriesStageType,
roundNumber?: number,
): string {
return formatBracketRoundLabel(stage, roundNumber, "라운드");
}
function formatBracketRoundLabel(
stage: SeriesStageType,
roundNumber: number | undefined,
roundUnit: "R" | "라운드",
): string {
const round = roundNumber ?? 1;
switch (stage) {
case "upper":
return round === 1
? `브래킷 1${roundUnit}`
: `브래킷 상위 ${round}${roundUnit}`;
case "lower":
return `브래킷 하위 ${round}${roundUnit}`;
case "grand-final":
return "그랜드 파이널";
case "reset-final":
return "리셋 파이널";
case "pair":
return "대진";
case "round-robin":
return `${round}라운드`;
}
}
function validateGraph(
projection: DoubleEliminationCompetitionProjection,
configuration: DoubleEliminationBracketConfiguration,
): ValidatedGraph | null {
if (projection.formatType !== "double-elimination") return null;
if (projection.series.length === 0) return null;
if (configuration.teamCount !== 4 && configuration.teamCount !== 8) {
return null;
}
const seriesById = new Map<
SeriesId,
DoubleEliminationCompetitionProjection["series"][number]
>();
const displayOrders = new Set<number>();
for (const series of projection.series) {
if (seriesById.has(series.seriesId)) return null;
if (!isBracketStage(series.stage.type)) return null;
if (!isRoundNumber(series.stage.roundNumber)) return null;
if (
!Number.isInteger(series.stage.displayOrder) ||
series.stage.displayOrder <= 0 ||
displayOrders.has(series.stage.displayOrder)
) {
return null;
}
displayOrders.add(series.stage.displayOrder);
seriesById.set(series.seriesId, series);
}
const normalizedRounds = normalizeRounds(projection.rounds, seriesById);
if (!normalizedRounds) return null;
const roundBySeriesId = new Map<SeriesId, NormalizedRound>();
for (const round of normalizedRounds) {
for (const seriesId of round.seriesIds) {
if (roundBySeriesId.has(seriesId)) return null;
roundBySeriesId.set(seriesId, round);
}
}
if (roundBySeriesId.size !== seriesById.size) return null;
const grandFinals = projection.series.filter(
({ stage }) => stage.type === "grand-final",
);
const resetFinals = projection.series.filter(
({ stage }) => stage.type === "reset-final",
);
if (
!matchesCanonicalShape(
projection,
normalizedRounds,
configuration,
grandFinals.length,
resetFinals.length,
)
) {
return null;
}
if (!hasContiguousRounds(normalizedRounds, "upper")) return null;
if (!hasContiguousRounds(normalizedRounds, "lower")) return null;
if (!connectorsHaveSupportedDiscriminators(projection.connectors)) return null;
const rankBySeriesId = rankConnectorDag(
projection.series.map(({ seriesId }) => seriesId),
projection.connectors,
seriesById,
);
if (!rankBySeriesId) return null;
if (!validateTopology(projection, seriesById, configuration)) {
return null;
}
for (const round of normalizedRounds) {
const ranks = new Set(
round.seriesIds.map((seriesId) => rankBySeriesId.get(seriesId)),
);
if (ranks.size !== 1 || ranks.has(undefined)) return null;
}
return {
seriesById,
roundBySeriesId,
rounds: normalizedRounds,
rankBySeriesId,
};
}
function normalizeRounds(
rounds: readonly BracketRoundView[],
seriesById: ValidatedGraph["seriesById"],
): NormalizedRound[] | null {
const keys = new Set<string>();
const result: NormalizedRound[] = [];
for (const round of rounds) {
if (!isBracketStage(round.stage) || !isRoundNumber(round.roundNumber)) {
return null;
}
const key = `${round.stage}:${round.roundNumber}`;
if (keys.has(key) || round.seriesIds.length === 0) return null;
keys.add(key);
const ids = [...round.seriesIds].sort((left, right) => {
const leftSeries = seriesById.get(left);
const rightSeries = seriesById.get(right);
return (
(leftSeries?.stage.displayOrder ?? 0) -
(rightSeries?.stage.displayOrder ?? 0)
);
});
for (const seriesId of ids) {
const series = seriesById.get(seriesId);
if (
!series ||
series.stage.type !== round.stage ||
series.stage.roundNumber !== round.roundNumber
) {
return null;
}
}
result.push({
stage: round.stage,
roundNumber: round.roundNumber,
label: bracketRoundLabel(round.stage, round.roundNumber),
accessibleLabel: bracketRoundAccessibleLabel(
round.stage,
round.roundNumber,
),
seriesIds: ids,
});
}
return result.sort(
(left, right) =>
STAGE_ORDER[left.stage] - STAGE_ORDER[right.stage] ||
left.roundNumber - right.roundNumber,
);
}
function rankConnectorDag(
seriesIds: readonly SeriesId[],
connectors: readonly SeriesConnectorView[],
seriesById: ValidatedGraph["seriesById"],
): Map<SeriesId, number> | null {
const indegree = new Map(seriesIds.map((seriesId) => [seriesId, 0]));
const outgoing = new Map(seriesIds.map((seriesId) => [seriesId, [] as SeriesId[]]));
const targetedSlots = new Set<string>();
for (const connector of connectors) {
const source = seriesById.get(connector.from.seriesId);
const target = seriesById.get(connector.to.seriesId);
if (!source || !target || source.seriesId === target.seriesId) return null;
const targetSlotKey = `${target.seriesId}:${connector.to.slot}`;
if (targetedSlots.has(targetSlotKey)) return null;
targetedSlots.add(targetSlotKey);
indegree.set(target.seriesId, (indegree.get(target.seriesId) ?? 0) + 1);
outgoing.get(source.seriesId)?.push(target.seriesId);
}
const rank = new Map(seriesIds.map((seriesId) => [seriesId, 0]));
const queue = seriesIds
.filter((seriesId) => indegree.get(seriesId) === 0)
.sort((left, right) =>
compareSeriesDisplayOrder(seriesById.get(left), seriesById.get(right)),
);
let processed = 0;
while (queue.length > 0) {
const sourceId = queue.shift();
if (!sourceId) break;
processed += 1;
for (const targetId of outgoing.get(sourceId) ?? []) {
rank.set(
targetId,
Math.max(rank.get(targetId) ?? 0, (rank.get(sourceId) ?? 0) + 1),
);
const remaining = (indegree.get(targetId) ?? 0) - 1;
indegree.set(targetId, remaining);
if (remaining === 0) {
queue.push(targetId);
queue.sort((left, right) =>
compareSeriesDisplayOrder(seriesById.get(left), seriesById.get(right)),
);
}
}
}
return processed === seriesIds.length ? rank : null;
}
function validateTopology(
projection: DoubleEliminationCompetitionProjection,
seriesById: ValidatedGraph["seriesById"],
configuration: DoubleEliminationBracketConfiguration,
): boolean {
const incoming = new Map<SeriesId, SeriesConnectorView[]>();
const sourceSelections = new Set<string>();
for (const connector of projection.connectors) {
const source = seriesById.get(connector.from.seriesId);
const target = seriesById.get(connector.to.seriesId);
if (
!source ||
!target ||
!isBracketStage(source.stage.type) ||
!isBracketStage(target.stage.type) ||
!isRoundNumber(source.stage.roundNumber) ||
!isRoundNumber(target.stage.roundNumber)
) {
return false;
}
const sourceSelectionKey = `${source.seriesId}:${connector.from.select}`;
if (sourceSelections.has(sourceSelectionKey)) return false;
sourceSelections.add(sourceSelectionKey);
if (
!isCanonicalTransition(
source.stage.type,
source.stage.roundNumber,
target.stage.type,
target.stage.roundNumber,
connector.from.select,
configuration,
)
) {
return false;
}
const list = incoming.get(connector.to.seriesId) ?? [];
list.push(connector);
incoming.set(connector.to.seriesId, list);
if (
connector.from.select === "slot-a" ||
connector.from.select === "slot-b"
) {
const expectedSlot = connector.from.select === "slot-a" ? "A" : "B";
if (connector.to.slot !== expectedSlot) return false;
}
}
for (const series of projection.series) {
const edges = incoming.get(series.seriesId) ?? [];
const isRoot = series.stage.type === "upper" && series.stage.roundNumber === 1;
if (isRoot) {
if (edges.length !== 0) return false;
continue;
}
if (
edges.length !== 2 ||
!edges.some(({ to }) => to.slot === "A") ||
!edges.some(({ to }) => to.slot === "B")
) {
return false;
}
}
return true;
}
function buildNodes(
graph: ValidatedGraph,
upperLane: DoubleEliminationBracketLayout["upperLane"],
lowerLane: DoubleEliminationBracketLayout["lowerLane"],
finalCenterY: number,
): BracketNodeLayout[] {
const geometry = DOUBLE_ELIMINATION_BRACKET_GEOMETRY;
const result: BracketNodeLayout[] = [];
for (const round of graph.rounds) {
const lane = laneForStage(round.stage);
const laneGeometry = lane === "upper" ? upperLane : lowerLane;
round.seriesIds.forEach((seriesId, index) => {
const column = graph.rankBySeriesId.get(seriesId) ?? 0;
const centerY =
lane === "final"
? finalCenterY
: laneGeometry.top +
(laneGeometry.height * (index + 0.5)) / round.seriesIds.length;
result.push({
seriesId,
label: seriesDisplayName(round, seriesId, round.label),
accessibleLabel: seriesDisplayName(
round,
seriesId,
round.accessibleLabel,
),
stage: round.stage,
roundNumber: round.roundNumber,
lane,
column,
x:
geometry.boardPadding +
column * (geometry.columnWidth + geometry.columnGap),
y: centerY - geometry.cardHeight / 2,
width: geometry.columnWidth,
height: geometry.cardHeight,
});
});
}
return result;
}
function buildRoundLayouts(
graph: ValidatedGraph,
nodeById: Map<SeriesId, BracketNodeLayout>,
upperLane: DoubleEliminationBracketLayout["upperLane"],
lowerLane: DoubleEliminationBracketLayout["lowerLane"],
): BracketRoundLayout[] {
return graph.rounds.map((round) => {
const node = nodeById.get(round.seriesIds[0]);
const lane = laneForStage(round.stage);
const labelY =
lane === "upper"
? upperLane.top - 28
: lane === "lower"
? lowerLane.top - 28
: (node?.y ?? 0) - 28;
return {
...round,
lane,
column: node?.column ?? 0,
x: node?.x ?? 0,
labelY,
};
});
}
function buildConnectors(
projection: DoubleEliminationCompetitionProjection,
graph: ValidatedGraph,
nodeById: Map<SeriesId, BracketNodeLayout>,
): BracketConnectorLayout[] | null {
const geometry = DOUBLE_ELIMINATION_BRACKET_GEOMETRY;
const routes: ConnectorRoute[] = [];
const routesByTargetColumn = new Map<number, ConnectorRoute[]>();
for (const connector of projection.connectors) {
const source = nodeById.get(connector.from.seriesId);
const target = nodeById.get(connector.to.seriesId);
if (!source || !target || target.column <= source.column) return null;
const route = {
connector,
key: connectorKey(connector),
kind: connectorKind(connector.from.select),
targetColumn: target.column,
targetNodeY: target.y,
sourceX: source.x + source.width,
sourceY: connectorAnchorY(source, connector.from.select),
targetX: target.x,
targetY: targetSlotY(target, connector.to.slot),
} satisfies ConnectorRoute;
routes.push(route);
const columnRoutes = routesByTargetColumn.get(target.column) ?? [];
columnRoutes.push(route);
routesByTargetColumn.set(target.column, columnRoutes);
}
const verticalXByConnector = new Map<string, number>();
for (const columnRoutes of routesByTargetColumn.values()) {
columnRoutes.sort(
(left, right) =>
right.sourceY - left.sourceY ||
right.targetY - left.targetY ||
left.key.localeCompare(right.key),
);
columnRoutes.forEach(({ key, targetX }, index) => {
verticalXByConnector.set(
key,
targetX -
geometry.columnGap +
(geometry.columnGap * (index + 1)) / (columnRoutes.length + 1),
);
});
}
if (!alignWinnerBundleRails(routes, verticalXByConnector)) return null;
const result: BracketConnectorLayout[] = [];
for (const route of routes) {
const { connector, key, kind, sourceX, sourceY, targetX, targetY } = route;
const verticalX = verticalXByConnector.get(key);
if (verticalX === undefined) return null;
result.push({
fromSeriesId: connector.from.seriesId,
select: connector.from.select,
toSeriesId: connector.to.seriesId,
toSlot: connector.to.slot,
kind,
sourceX,
sourceY,
verticalX,
targetX,
targetY,
path: `M ${number(sourceX)} ${number(sourceY)} H ${number(verticalX)} V ${number(targetY)} H ${number(targetX)}`,
label: connectorLabel(connector, graph, "label"),
accessibleLabel: connectorLabel(connector, graph, "accessibleLabel"),
});
}
return result.sort(
(left, right) =>
compareSeriesDisplayOrder(
graph.seriesById.get(left.fromSeriesId),
graph.seriesById.get(right.fromSeriesId),
) ||
CONNECTOR_SELECTION_ORDER[left.select] -
CONNECTOR_SELECTION_ORDER[right.select] ||
compareSeriesDisplayOrder(
graph.seriesById.get(left.toSeriesId),
graph.seriesById.get(right.toSeriesId),
) ||
left.toSlot.localeCompare(right.toSlot),
);
}
function alignWinnerBundleRails(
routes: readonly ConnectorRoute[],
verticalXByConnector: Map<string, number>,
): boolean {
const winnersByTarget = new Map<SeriesId, ConnectorRoute[]>();
for (const route of routes) {
if (route.kind !== "winner") continue;
const winners = winnersByTarget.get(route.connector.to.seriesId) ?? [];
winners.push(route);
winnersByTarget.set(route.connector.to.seriesId, winners);
}
const bundles = [...winnersByTarget.values()]
.filter(
(winners) =>
winners.length === 2 &&
winners[0].connector.to.slot !== winners[1].connector.to.slot,
)
.sort(
(left, right) =>
left[0].targetColumn - right[0].targetColumn ||
left[0].targetNodeY - right[0].targetNodeY ||
left[0].key.localeCompare(right[0].key),
);
for (const bundle of bundles) {
const preferredX =
bundle[0].targetX - DOUBLE_ELIMINATION_BRACKET_GEOMETRY.columnGap / 2;
if (
intervalsOverlap(
bundle[0].sourceY,
bundle[0].targetY,
bundle[1].sourceY,
bundle[1].targetY,
)
) {
const assignment = chooseSeparateWinnerRails(
bundle,
routes,
verticalXByConnector,
preferredX,
);
if (!assignment) return false;
for (const [key, verticalX] of assignment) {
verticalXByConnector.set(key, verticalX);
}
continue;
}
const verticalX = chooseWinnerBundleRail(
bundle,
routes,
verticalXByConnector,
preferredX,
);
if (verticalX === null) return false;
for (const route of bundle) verticalXByConnector.set(route.key, verticalX);
}
return true;
}
function chooseWinnerBundleRail(
bundle: readonly ConnectorRoute[],
routes: readonly ConnectorRoute[],
verticalXByConnector: Map<string, number>,
preferredX: number,
): number | null {
const previousRails = bundle.map((route) =>
verticalXByConnector.get(route.key),
);
if (previousRails.some((verticalX) => verticalX === undefined)) return null;
const previousScore = connectorConflictScore(routes, verticalXByConnector);
// Keep the existing crossing budget, then favor stroke-clear rails nearest center.
let best:
| {
verticalX: number;
crossings: number;
clearanceConflicts: number;
distanceFromCenter: number;
}
| null = null;
for (const candidateX of winnerRailCandidates(preferredX)) {
for (const route of bundle) {
verticalXByConnector.set(route.key, candidateX);
}
const score = connectorConflictScore(routes, verticalXByConnector);
if (
score.overlaps !== 0 ||
score.crossings > previousScore.crossings ||
score.clearanceConflicts > previousScore.clearanceConflicts
) {
continue;
}
const distanceFromCenter = Math.abs(candidateX - preferredX);
if (
!best ||
score.clearanceConflicts < best.clearanceConflicts ||
(score.clearanceConflicts === best.clearanceConflicts &&
(score.crossings < best.crossings ||
(score.crossings === best.crossings &&
distanceFromCenter < best.distanceFromCenter)))
) {
best = {
verticalX: candidateX,
crossings: score.crossings,
clearanceConflicts: score.clearanceConflicts,
distanceFromCenter,
};
}
}
if (best) return best.verticalX;
bundle.forEach((route, index) => {
const previousX = previousRails[index];
if (previousX !== undefined) {
verticalXByConnector.set(route.key, previousX);
}
});
return null;
}
function winnerRailCandidates(preferredX: number): number[] {
const geometry = DOUBLE_ELIMINATION_BRACKET_GEOMETRY;
const maximumOffset =
geometry.columnGap / 2 - CONNECTOR_RAIL_EDGE_INSET;
const candidates = [preferredX];
for (let offset = 1; offset <= maximumOffset; offset += 1) {
candidates.push(preferredX - offset, preferredX + offset);
}
return candidates;
}
function chooseSeparateWinnerRails(
bundle: readonly ConnectorRoute[],
routes: readonly ConnectorRoute[],
verticalXByConnector: Map<string, number>,
preferredX: number,
): Map<string, number> | null {
const orderedBundle = [...bundle].sort(
(left, right) =>
left.sourceY - right.sourceY ||
left.targetY - right.targetY ||
left.key.localeCompare(right.key),
);
const previousRails: number[] = [];
for (const route of orderedBundle) {
const previousX = verticalXByConnector.get(route.key);
if (previousX === undefined) return null;
previousRails.push(previousX);
}
const previousScore = connectorConflictScore(routes, verticalXByConnector);
const bundleKeys = new Set(orderedBundle.map(({ key }) => key));
const candidates = [
...new Set([...previousRails, ...winnerRailCandidates(preferredX)]),
];
let best: SeparateWinnerRailChoice | null = null;
for (const firstX of candidates) {
for (const secondX of candidates) {
if (firstX === secondX) continue;
verticalXByConnector.set(orderedBundle[0].key, firstX);
verticalXByConnector.set(orderedBundle[1].key, secondX);
const bundleScore = connectorConflictScore(
routes,
verticalXByConnector,
bundleKeys,
);
const score = connectorConflictScore(routes, verticalXByConnector);
if (
bundleScore.overlaps !== 0 ||
bundleScore.clearanceConflicts !== 0 ||
score.overlaps !== 0 ||
score.crossings > previousScore.crossings
) {
continue;
}
const distanceFromBaseline =
Math.abs(firstX - previousRails[0]) +
Math.abs(secondX - previousRails[1]);
const distanceFromCenter =
Math.abs(firstX - preferredX) + Math.abs(secondX - preferredX);
const candidate: SeparateWinnerRailChoice = {
verticalXs: [firstX, secondX],
crossings: score.crossings,
distanceFromBaseline,
distanceFromCenter,
};
if (!best || compareSeparateWinnerRailChoices(candidate, best) < 0) {
best = candidate;
}
}
}
orderedBundle.forEach((route, index) => {
verticalXByConnector.set(route.key, previousRails[index]);
});
if (!best) return null;
return new Map(
orderedBundle.map((route, index) => [route.key, best.verticalXs[index]]),
);
}
function compareSeparateWinnerRailChoices(
left: SeparateWinnerRailChoice,
right: SeparateWinnerRailChoice,
): number {
return (
left.crossings - right.crossings ||
left.distanceFromBaseline - right.distanceFromBaseline ||
left.distanceFromCenter - right.distanceFromCenter ||
left.verticalXs[0] - right.verticalXs[0] ||
left.verticalXs[1] - right.verticalXs[1]
);
}
function connectorConflictScore(
routes: readonly ConnectorRoute[],
verticalXByConnector: ReadonlyMap<string, number>,
focusedRouteKeys?: ReadonlySet<string>,
): { crossings: number; overlaps: number; clearanceConflicts: number } {
let crossings = 0;
let overlaps = 0;
let clearanceConflicts = 0;
for (let leftIndex = 0; leftIndex < routes.length; leftIndex += 1) {
const leftX = verticalXByConnector.get(routes[leftIndex].key);
if (leftX === undefined) continue;
const leftSegments = connectorRouteSegments(routes[leftIndex], leftX);
for (
let rightIndex = leftIndex + 1;
rightIndex < routes.length;
rightIndex += 1
) {
if (
focusedRouteKeys &&
!focusedRouteKeys.has(routes[leftIndex].key) &&
!focusedRouteKeys.has(routes[rightIndex].key)
) {
continue;
}
const rightX = verticalXByConnector.get(routes[rightIndex].key);
if (rightX === undefined) continue;
const rightSegments = connectorRouteSegments(routes[rightIndex], rightX);
for (const left of leftSegments) {
for (const right of rightSegments) {
if (left.orientation === right.orientation) {
const overlapLength =
Math.min(left.end, right.end) - Math.max(left.start, right.start);
if (left.fixed === right.fixed && overlapLength > 0) {
overlaps += 1;
} else if (
left.orientation === "vertical" &&
overlapLength > 0 &&
Math.abs(left.fixed - right.fixed) <
DOUBLE_ELIMINATION_BRACKET_GEOMETRY.connectorRailClearance
) {
clearanceConflicts += 1;
}
continue;
}
const horizontal =
left.orientation === "horizontal" ? left : right;
const vertical = left.orientation === "vertical" ? left : right;
if (
vertical.fixed > horizontal.start &&
vertical.fixed < horizontal.end &&
horizontal.fixed > vertical.start &&
horizontal.fixed < vertical.end
) {
crossings += 1;
}
}
}
}
}
return { crossings, overlaps, clearanceConflicts };
}
function connectorRouteSegments(
route: ConnectorRoute,
verticalX: number,
): OrthogonalSegment[] {
return [
orthogonalSegment("horizontal", route.sourceY, route.sourceX, verticalX),
orthogonalSegment("vertical", verticalX, route.sourceY, route.targetY),
orthogonalSegment("horizontal", route.targetY, verticalX, route.targetX),
];
}
function orthogonalSegment(
orientation: OrthogonalSegment["orientation"],
fixed: number,
first: number,
second: number,
): OrthogonalSegment {
return {
orientation,
fixed,
start: Math.min(first, second),
end: Math.max(first, second),
};
}
function intervalsOverlap(
firstStart: number,
firstEnd: number,
secondStart: number,
secondEnd: number,
): boolean {
return (
Math.min(firstStart, firstEnd) < Math.max(secondStart, secondEnd) &&
Math.min(secondStart, secondEnd) < Math.max(firstStart, firstEnd)
);
}
function connectorLabel(
connector: SeriesConnectorView,
graph: ValidatedGraph,
labelKey: "label" | "accessibleLabel",
): string {
const sourceRound = graph.roundBySeriesId.get(connector.from.seriesId);
const targetRound = graph.roundBySeriesId.get(connector.to.seriesId);
const sourceName = seriesDisplayName(
sourceRound,
connector.from.seriesId,
sourceRound?.[labelKey],
);
const targetName = seriesDisplayName(
targetRound,
connector.to.seriesId,
targetRound?.[labelKey],
);
const selection =
connector.from.select === "winner"
? "승자"
: connector.from.select === "loser"
? "패자"
: connector.from.select === "slot-a"
? "A팀"
: "B팀";
return `${sourceName} ${selection} → ${targetName} ${connector.to.slot} 슬롯`;
}
function seriesDisplayName(
round: NormalizedRound | undefined,
seriesId: SeriesId,
roundLabel: string | undefined,
): string {
if (!round || !roundLabel) return "알 수 없는 경기";
const index = round.seriesIds.indexOf(seriesId);
return round.seriesIds.length > 1
? `${roundLabel} · ${index + 1}경기`
: roundLabel;
}
function connectorAnchorY(
node: BracketNodeLayout,
select: SeriesConnectorView["from"]["select"],
): number {
const center = node.y + node.height / 2;
switch (select) {
case "winner":
return center - 7;
case "loser":
return center + 7;
case "slot-a":
return targetSlotY(node, "A");
case "slot-b":
return targetSlotY(node, "B");
}
}
function targetSlotY(node: BracketNodeLayout, slot: SeriesSlot): number {
const geometry = DOUBLE_ELIMINATION_BRACKET_GEOMETRY;
const rowIndex = slot === "A" ? 0 : 1;
return (
node.y +
geometry.cardBorderWidth +
geometry.cardHeaderHeight +
geometry.cardEntryHeight * (rowIndex + 0.5)
);
}
function connectorKind(
select: SeriesConnectorView["from"]["select"],
): BracketConnectorKind {
if (select === "winner") return "winner";
if (select === "loser") return "loser";
return "reset";
}
function connectorKey(connector: SeriesConnectorView): string {
return `${connector.from.seriesId}:${connector.from.select}:${connector.to.seriesId}:${connector.to.slot}`;
}
function matchesCanonicalShape(
projection: DoubleEliminationCompetitionProjection,
rounds: readonly NormalizedRound[],
configuration: DoubleEliminationBracketConfiguration,
grandFinalCount: number,
resetFinalCount: number,
): boolean {
const expectedUpper =
configuration.teamCount === 4 ? [2, 1] : [4, 2, 1];
const expectedLower =
configuration.teamCount === 4 ? [1, 1] : [2, 2, 1, 1];
const resetCount = configuration.resetFinalEnabled ? 1 : 0;
const expectedSeriesCount = configuration.teamCount * 2 - 2 + resetCount;
const expectedConnectorCount =
configuration.teamCount * 3 - 4 + resetCount * 2;
return (
projection.series.length === expectedSeriesCount &&
projection.connectors.length === expectedConnectorCount &&
grandFinalCount === 1 &&
resetFinalCount === resetCount &&
roundSizes(rounds, "upper").every(
(size, index) => size === expectedUpper[index],
) &&
roundSizes(rounds, "upper").length === expectedUpper.length &&
roundSizes(rounds, "lower").every(
(size, index) => size === expectedLower[index],
) &&
roundSizes(rounds, "lower").length === expectedLower.length &&
rounds.filter(({ stage }) => stage === "grand-final").length === 1 &&
rounds
.filter(({ stage }) => stage === "grand-final")
.every(({ roundNumber, seriesIds }) => roundNumber === 1 && seriesIds.length === 1) &&
rounds.filter(({ stage }) => stage === "reset-final").length === resetCount &&
rounds
.filter(({ stage }) => stage === "reset-final")
.every(({ roundNumber, seriesIds }) => roundNumber === 1 && seriesIds.length === 1)
);
}
function roundSizes(
rounds: readonly NormalizedRound[],
stage: "upper" | "lower",
): number[] {
return rounds
.filter((round) => round.stage === stage)
.sort((left, right) => left.roundNumber - right.roundNumber)
.map(({ seriesIds }) => seriesIds.length);
}
function connectorsHaveSupportedDiscriminators(
connectors: readonly SeriesConnectorView[],
): boolean {
return connectors.every(
(connector) =>
isConnectorSelection(connector.from.select) &&
isSeriesSlot(connector.to.slot),
);
}
function isCanonicalTransition(
sourceStage: BracketStage,
sourceRound: number,
targetStage: BracketStage,
targetRound: number,
select: SeriesConnectorView["from"]["select"],
configuration: DoubleEliminationBracketConfiguration,
): boolean {
const upperFinalRound = configuration.teamCount === 4 ? 2 : 3;
const lowerFinalRound = configuration.teamCount === 4 ? 2 : 4;
if (select === "winner") {
if (sourceStage === "upper") {
return sourceRound < upperFinalRound
? targetStage === "upper" && targetRound === sourceRound + 1
: sourceRound === upperFinalRound && targetStage === "grand-final";
}
if (sourceStage === "lower") {
return sourceRound < lowerFinalRound
? targetStage === "lower" && targetRound === sourceRound + 1
: sourceRound === lowerFinalRound && targetStage === "grand-final";
}
return false;
}
if (select === "loser") {
return (
sourceStage === "upper" &&
targetStage === "lower" &&
targetRound ===
(sourceRound === upperFinalRound ? lowerFinalRound : sourceRound)
);
}
return sourceStage === "grand-final" && targetStage === "reset-final";
}
function laneHeight(rounds: readonly NormalizedRound[]): number {
const geometry = DOUBLE_ELIMINATION_BRACKET_GEOMETRY;
const maxSeries = Math.max(...rounds.map(({ seriesIds }) => seriesIds.length), 1);
return maxSeries * (geometry.cardHeight + geometry.cardGap);
}
function laneForStage(stage: BracketStage): BracketLane {
if (stage === "upper") return "upper";
if (stage === "lower") return "lower";
return "final";
}
function hasContiguousRounds(
rounds: readonly NormalizedRound[],
stage: "upper" | "lower",
): boolean {
const numbers = rounds
.filter((round) => round.stage === stage)
.map(({ roundNumber }) => roundNumber)
.sort((left, right) => left - right);
return (
numbers.length > 0 && numbers.every((roundNumber, index) => roundNumber === index + 1)
);
}
function isBracketStage(stage: SeriesStageType): stage is BracketStage {
return (
stage === "upper" ||
stage === "lower" ||
stage === "grand-final" ||
stage === "reset-final"
);
}
function isRoundNumber(value: number | undefined): value is number {
return Number.isInteger(value) && (value ?? 0) > 0;
}
function isConnectorSelection(
value: unknown,
): value is SeriesConnectorView["from"]["select"] {
return (
value === "winner" ||
value === "loser" ||
value === "slot-a" ||
value === "slot-b"
);
}
function isSeriesSlot(value: unknown): value is SeriesSlot {
return value === "A" || value === "B";
}
function compareSeriesDisplayOrder(
left: DoubleEliminationCompetitionProjection["series"][number] | undefined,
right: DoubleEliminationCompetitionProjection["series"][number] | undefined,
): number {
return (left?.stage.displayOrder ?? 0) - (right?.stage.displayOrder ?? 0);
}
function number(value: number): string {
return Number.isInteger(value) ? String(value) : value.toFixed(1);
}