feat(series): add series/cup championships with points tables and standings

Group any number of races in freely chosen classes into a series with a
points table (ÖRC/100-80-70/F1/custom), best-N or drop-X counting, a
club filter that re-ranks members without guests, tie-breaks, rounds
created from a date list, and per-class standings with print and PDF.

Also fixes PDF export of wide tables: they are compacted and switched
to landscape instead of truncating names and dropping columns.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
larssandandClaude Opus 5.5 committed 2026-10-10 19:49:23 +02:00
1 parent f65e526948
commit 9a9379aa83
18 files changed
+848 -20

No files matched your search

+187
View File
@@ -9,6 +9,8 @@ import { recordTransponderSighting, buildWarmupCheck, createPrologue, getPrologu
import { findTransponderConflict, getDriverProfileId } from "./driver_profile_logic.js";
import { renderRaceDayView, refreshRaceDayWarmup, refreshRaceDayPrologueClock, updateRaceDayStartDisplay } from "./race_day_view.js";
import { beginSession as beginSessionControl, finishSession as finishSessionControl, pauseSession as pauseSessionControl, resumeSession as resumeSessionControl } from "./session_control.js";
import { normalizeSeries, buildSeriesStandings } from "./series_logic.js";
import { renderSeriesView } from "./series_view.js";
import { RACE_AUDIO_EVENT_DEFINITIONS, createRaceAudioEngine, normalizeRaceAudioSettings, isSilencedDuringRace } from "./race_audio.js";
import { renderRaceFormatField, renderRaceFormatContextCard, getRaceSummaryItems, getRaceSummaryWarnings, renderManageStatusBadge, renderRaceWizardSteps, renderRaceWizardContent, renderRaceStandingsTable } from "./race_setup_ui.js";
@@ -88,6 +90,7 @@ const getSessionTypeLabel = (type) => getSessionTypeLabelLogic(type, { t });
const getStatusLabel = (status) => getStatusLabelLogic(status, { t });
const isUntimedSession = (session) => isUntimedSessionLogic(session);
const getActiveSession = () => getActiveSessionLogic({ state });
const normalizeSeriesList = (list) => (Array.isArray(list) ? list : []).map((series) => normalizeSeries(series, { uid })).filter((series) => series.id);
const getSessionTargetMs = (session) => getSessionTargetMsLogic(session, { isUntimedSession });
const getSessionLapWindow = (session) => getSessionLapWindowLogic(session, { state });
const isCountedPassing = (passing) => isCountedPassingLogic(passing);
@@ -489,6 +492,84 @@ const buildStepTrainingProgress = (trainingState, driverId, classId, config, now
const buildTrainingRecommendation = (stats) => buildTrainingRecommendationLogic(stats);
const getTrainingGoalProgress = (goal, stats, exerciseSessionCount) => getTrainingGoalProgressLogic(goal, stats, exerciseSessionCount);
const getNextTrainingMilestone = (stats) => getNextTrainingMilestoneLogic(stats);
// --- Series / cup ---------------------------------------------------------------------
// The day result a series scores: the final standings (A before B ...), then drivers who
// raced no final in qualifying order; or the qualifying order alone if no finals ran. Only
// once at least one qualifying/heat/final of the event is finished. `hasLap`: at least one
// counted lap in any of them (no lap = 0 series points).
const getEventDayResult = (event) => {
const sessions = getSessionsForEvent(event.id).filter((session) => ["qualification", "heat", "final"].includes(session.type));
if (!sessions.some((session) => session.status === "finished")) return [];
const lapped = new Set();
sessions.forEach((session) => (state.resultsBySession[session.id]?.passings || []).forEach((passing) => {
if (passing.validLap !== false && passing.driverId) lapped.add(String(passing.driverId));
}));
const order = [];
const add = (row) => { if (row?.driverId && !order.some((item) => item.driverId === row.driverId)) order.push({ driverId: row.driverId, driverName: row.driverName, hasLap: lapped.has(String(row.driverId)) }); };
buildFinalStandings(event).forEach(add);
buildQualifyingStandings(event).forEach(add);
return order;
};
const getSeriesStandings = (series) => buildSeriesStandings(series, {
events: state.events,
dayResults: new Map(state.events.filter((event) => series.eventIds.includes(event.id)).map((event) => [event.id, getEventDayResult(event)])),
getDriverClub: (driverId) => state.drivers.find((driver) => driver.id === driverId)?.club || "",
getDriverName: (driverId) => state.drivers.find((driver) => driver.id === driverId)?.name || "",
classNames: new Map(state.classes.map((item) => [item.id, item.name])),
});
// One race per date and class, named "<series> #<round> <class>", with the chosen race format.
const createSeriesEvents = (series, dates, presetId) => {
const existingDates = new Set(state.events.filter((event) => series.eventIds.includes(event.id)).map((event) => event.date));
const allDates = [...new Set([...existingDates, ...dates])].sort();
let created = 0;
[...new Set(dates)].sort().forEach((date) => {
const round = allDates.indexOf(date) + 1;
series.classIds.forEach((classId) => {
if (state.events.some((event) => series.eventIds.includes(event.id) && event.date === date && event.classId === classId)) return;
const event = normalizeEvent({ id: uid("event"), name: `${series.name} #${round} ${getClassName(classId)}`, date, classId, mode: "race" });
applyRaceFormatPreset(event, presetId);
state.events.push(event);
series.eventIds.push(event.id);
created += 1;
});
});
saveState();
return created;
};
const seriesCell = (table, row, event) => {
const result = row.results.find((item) => item.eventId === event.id);
if (!event.completed || !result) return "";
const text = result.absent ? "-" : String(result.points);
return result.counted ? text : `(${text})`;
};
const seriesSubtitle = (series) => [series.club, t("series.count_rule", { rule: series.countMode === "drop" ? t("series.count_drop_value", { count: series.countValue }) : t("series.count_best_value", { count: series.countValue }) })].filter(Boolean).join(" • ");
const printSeries = (series, tables) => openPrintWindow(series.name, `
<div class="print-header"><div><p class="print-kicker">${escapeHtml(t("series.standings"))}</p><h1>${escapeHtml(series.name)}</h1><p>${escapeHtml(seriesSubtitle(series))}</p></div>
<div class="print-meta"><p>${escapeHtml(new Date().toLocaleDateString())}</p></div></div>
${tables.map((table) => `<div class="print-block"><h2>${escapeHtml(table.className)} - ${escapeHtml(t("series.counted_of", { counted: table.countedCount, completed: table.completedCount, total: table.events.length }))}</h2>
<table><thead><tr><th>${escapeHtml(t("table.pos"))}</th><th>${escapeHtml(t("table.driver"))}</th>${table.events.map((event, index) => `<th>${index + 1}</th>`).join("")}<th>${escapeHtml(t("series.starts"))}</th><th>${escapeHtml(t("series.total"))}</th></tr></thead>
<tbody>${table.rows.map((row) => `<tr><td>${row.rank}</td><td>${escapeHtml(row.driverName)}</td>${table.events.map((event) => `<td>${escapeHtml(seriesCell(table, row, event))}</td>`).join("")}<td>${row.starts}</td><td><strong>${row.total}</strong></td></tr>`).join("")}</tbody></table>
<p>${table.events.map((event, index) => `${index + 1}: ${escapeHtml(event.date || "")} ${escapeHtml(event.name)}`).join(" · ")}</p></div>`).join("")}
<p>${escapeHtml(t("series.legend"))}</p>`);
const exportSeriesPdf = async (series, tables) => {
const branding = resolveEventBranding(state.events.find((event) => series.eventIds.includes(event.id)) || {});
await requestPdfExport({
filename: `${(series.name || "series").replaceAll(/\s+/g, "_")}_standings.pdf`,
title: series.name,
subtitle: seriesSubtitle(series),
brandName: branding.brandName,
brandTagline: branding.brandTagline,
footer: branding.pdfFooter,
theme: branding.pdfTheme,
logoDataUrl: await ensurePdfLogoDataUrl(branding.logoDataUrl),
sections: tables.map((table) => buildPdfSection(
`${table.className} - ${t("series.counted_of", { counted: table.countedCount, completed: table.completedCount, total: table.events.length })}`,
[t("table.pos"), t("table.driver"), ...table.events.map((event, index) => String(index + 1)), t("series.starts"), t("series.total")],
table.rows.map((row) => [String(row.rank), row.driverName, ...table.events.map((event) => seriesCell(table, row, event)), String(row.starts), String(row.total)]),
)),
});
};
const renderSeries = () => renderSeriesView({ state, dom, t, escapeHtml, saveState, renderView, uid, getClassName, getSeriesStandings, createSeriesEvents, getRaceFormatPresets, exportSeriesPdf, printSeries });
const renderArchive = () => renderResultsArchiveView({
state, dom, t, escapeHtml, formatLap, formatRaceClock, renderTable,
getClassName, getEventName, buildLeaderboard, getCompetitorPassings,
@@ -525,6 +606,7 @@ const NAV_ITEMS = [
{ id: "race_day", titleKey: "nav.race_day", subtitleKey: "nav.race_day_sub", groupKey: "nav.group_start" },
{ id: "race_setup", titleKey: "nav.race_setup", subtitleKey: "nav.race_setup_sub", groupKey: "nav.group_create" },
{ id: "events", titleKey: "nav.events", subtitleKey: "nav.events_sub", groupKey: "nav.group_create" },
{ id: "series", titleKey: "nav.series", subtitleKey: "nav.series_sub", groupKey: "nav.group_create" },
{ id: "timing", titleKey: "nav.timing", subtitleKey: "nav.timing_sub", groupKey: "nav.group_run" },
{ id: "judging", titleKey: "nav.judging", subtitleKey: "nav.judging_sub", groupKey: "nav.group_run" },
{ id: "overlay", titleKey: "nav.overlay", subtitleKey: "nav.overlay_sub", groupKey: "nav.group_run" },
@@ -617,6 +699,55 @@ const TRANSLATIONS = {
"nav.group_system": "System och hjälp",
"nav.events": "Sponsor Event",
"nav.events_sub": "Sponsor-event och delade bilar",
"nav.series": "Serier / cup",
"nav.series_sub": "Poäng över flera race",
"series.title": "Serier och cuper",
"series.hint": "Samla flera race i en serie med poäng per placering. Välj klasser, poängtabell och hur många resultat som räknas. Ställningen räknas per klass.",
"series.new": "Ny serie",
"series.new_name": "Serie {year}",
"series.none": "Inga serier ännu.",
"series.unnamed": "Namnlös serie",
"series.settings": "Inställningar",
"series.name": "Namn",
"series.name_placeholder": "t.ex. Winter Championship 2026/2027",
"series.club": "Klubb (bara dess förare får poäng)",
"series.club_all": "tomt = alla får poäng",
"series.club_hint": "Förare från andra klubbar kör och syns i dagens resultat men får inga seriepoäng; klubbens förare rangordnas om utan dem. Klubben hämtas från förarregistret.",
"series.classes": "Klasser (en tabell per klass)",
"series.no_classes": "Skapa klasser först under Klasser.",
"series.points_preset": "Poängtabell",
"series.preset_orc": "100, 90, 82, 75, 69 ... (-4, lägst 10)",
"series.preset_hundred": "100, 80, 70, 60, 50 ... (-5, lägst 5)",
"series.preset_f1": "F1: 25, 18, 15, 12, 10 ...",
"series.preset_custom": "Egen",
"series.points_table": "Poäng plats 1, 2, 3 ...",
"series.points_table_hint": "Kommaseparerat, t.ex. 100, 80, 70, 60.",
"series.points_after": "Efter tabellen: minus per plats / lägst",
"series.points_after_hint": "0 / 0 = inga poäng efter tabellen.",
"series.count_mode": "Räknade resultat",
"series.count_best": "Bästa N räknas",
"series.count_drop": "Alla genomförda utom X sämsta",
"series.count_value": "N eller X",
"series.count_hint": "T.ex. bästa 9 av 12, eller stryk 3 (räknar automatiskt om ett race ställs in). Frånvaro = 0 och kan strykas.",
"series.count_rule": "räknas: {rule}",
"series.count_best_value": "bästa {count}",
"series.count_drop_value": "alla utom {count} sämsta",
"series.events": "Deltävlingar ({count})",
"series.events_hint": "Bocka i racen som ingår, eller skapa dem på en gång: ett race per datum och klass. Lägg sedan till förare och generera heat i Race Setup som vanligt.",
"series.no_events": "Inga race i de valda klasserna ännu - skapa dem nedan.",
"series.create_dates": "Skapa deltävlingar för datum",
"series.create_dates_hint": "Ett datum per rad (ÅÅÅÅ-MM-DD). Ett race skapas per datum och vald klass.",
"series.create_dates_invalid": "Ange minst ett datum som ÅÅÅÅ-MM-DD.",
"series.create_events": "Skapa deltävlingar",
"series.pick_classes_first": "Välj klasser och spara först.",
"series.standings": "Ställning",
"series.print": "Skriv ut",
"series.starts": "Starter",
"series.total": "Summa",
"series.counted_of": "{counted} räknas av {completed} körda ({total} planerade)",
"series.no_results": "Inga körda deltävlingar ännu.",
"series.legend": "Siffra = seriepoäng. (Inom parentes) = struket resultat. – = deltog inte. Lika poäng: flest segrar, sedan andraplatser osv., sedan senaste gemensamma deltävling.",
"series.delete_confirm": "Ta bort serien \"{name}\"? Racen och deras resultat finns kvar.",
"nav.race_setup": "Race Setup",
"nav.race_setup_sub": "Open Practice, klubbrace och endurance",
"nav.overlay": "Overlay",
@@ -2282,6 +2413,55 @@ const TRANSLATIONS = {
"nav.group_system": "System and help",
"nav.events": "Sponsor Events",
"nav.events_sub": "Sponsor events and shared cars",
"nav.series": "Series / cup",
"nav.series_sub": "Points across several races",
"series.title": "Series and cups",
"series.hint": "Group several races into a series with points per place. Choose classes, points table and how many results count. Standings are per class.",
"series.new": "New series",
"series.new_name": "Series {year}",
"series.none": "No series yet.",
"series.unnamed": "Unnamed series",
"series.settings": "Settings",
"series.name": "Name",
"series.name_placeholder": "e.g. Winter Championship 2026/2027",
"series.club": "Club (only its drivers score)",
"series.club_all": "empty = everyone scores",
"series.club_hint": "Drivers from other clubs race and appear in the day result but get no series points; the club's drivers are re-ranked without them. The club comes from the driver register.",
"series.classes": "Classes (one table per class)",
"series.no_classes": "Create classes first under Classes.",
"series.points_preset": "Points table",
"series.preset_orc": "100, 90, 82, 75, 69 ... (-4, min 10)",
"series.preset_hundred": "100, 80, 70, 60, 50 ... (-5, min 5)",
"series.preset_f1": "F1: 25, 18, 15, 12, 10 ...",
"series.preset_custom": "Custom",
"series.points_table": "Points for place 1, 2, 3 ...",
"series.points_table_hint": "Comma separated, e.g. 100, 80, 70, 60.",
"series.points_after": "After the table: minus per place / minimum",
"series.points_after_hint": "0 / 0 = no points after the table.",
"series.count_mode": "Counted results",
"series.count_best": "Best N count",
"series.count_drop": "All completed except the X worst",
"series.count_value": "N or X",
"series.count_hint": "E.g. best 9 of 12, or drop 3 (adjusts automatically if a race is cancelled). Absence = 0 and can be dropped.",
"series.count_rule": "counted: {rule}",
"series.count_best_value": "best {count}",
"series.count_drop_value": "all but the {count} worst",
"series.events": "Rounds ({count})",
"series.events_hint": "Tick the races that belong to the series, or create them in one go: one race per date and class. Then add drivers and generate heats in Race Setup as usual.",
"series.no_events": "No races in the selected classes yet - create them below.",
"series.create_dates": "Create rounds for dates",
"series.create_dates_hint": "One date per line (YYYY-MM-DD). One race is created per date and selected class.",
"series.create_dates_invalid": "Enter at least one date as YYYY-MM-DD.",
"series.create_events": "Create rounds",
"series.pick_classes_first": "Choose classes and save first.",
"series.standings": "Standings",
"series.print": "Print",
"series.starts": "Starts",
"series.total": "Total",
"series.counted_of": "{counted} counted of {completed} run ({total} planned)",
"series.no_results": "No rounds run yet.",
"series.legend": "Number = series points. (In brackets) = dropped result. – = did not take part. Ties: most wins, then 2nd places etc., then the latest common round.",
"series.delete_confirm": "Delete the series \"{name}\"? The races and their results are kept.",
"nav.race_setup": "Race Setup",
"nav.race_setup_sub": "Open Practice, club races and endurance",
"nav.overlay": "Overlay",
@@ -4369,6 +4549,7 @@ function seedDefaultData() {
state.sessions = state.sessions.map((session) => normalizeSession(session));
state.training = normalizeTrainingState(state.training);
state.trackLayouts = normalizeTrackLayouts(state.trackLayouts, { uid });
state.series = normalizeSeriesList(state.series);
saveState({ skipBackend: true });
}
@@ -4389,6 +4570,7 @@ function loadState() {
training: normalizeTrainingState(parsed.training),
activeSessionId: parsed.activeSessionId || null,
trackLayouts: normalizeTrackLayouts(parsed.trackLayouts, { uid }),
series: normalizeSeriesList(parsed.series),
settings: {
wsUrl: parsed.settings?.wsUrl || "ws://127.0.0.1:9000",
splitDecoderEnabled: parsed.settings?.splitDecoderEnabled === true,
@@ -4460,6 +4642,7 @@ function loadState() {
training: normalizeTrainingState(),
activeSessionId: null,
trackLayouts: [],
series: [],
settings: {
wsUrl: "ws://127.0.0.1:9000",
splitDecoderEnabled: false,
@@ -4724,6 +4907,7 @@ function buildPersistableState() {
activeSessionId: state.activeSessionId,
settings: state.settings,
trackLayouts: normalizeTrackLayouts(state.trackLayouts, { uid }),
series: normalizeSeriesList(state.series),
};
}
@@ -5334,6 +5518,9 @@ function renderView() {
case "archive":
renderArchive();
break;
case "series":
renderSeries();
break;
case "timing":
renderTiming();
break;