const root = document.getElementById("publicTrainingRoot");
const shareToken = decodeURIComponent(window.location.pathname.split("/").filter(Boolean).at(-1) || "");
const requestedLanguage = new URLSearchParams(window.location.search).get("lang");
const language = requestedLanguage === "en" || requestedLanguage === "sv"
? requestedLanguage
: String(navigator.language || "sv").toLowerCase().startsWith("sv") ? "sv" : "en";
const DEFAULT_TIMER_CONFIG = Object.freeze({ pushMinutes: 10, controlMinutes: 10 });
const MAX_TIMER_BLOCK_MINUTES = 120;
let selectedClassId = new URLSearchParams(window.location.search).get("class") || "";
let selectedLayout = new URLSearchParams(window.location.search).get("layout") || "current";
let selectedSource = new URLSearchParams(window.location.search).get("source") || "practice";
const messages = {
sv: {
connection_loading: "Hämtar statistik...",
connection_current: "Statistiken är uppdaterad.",
connection_failed: "Uppdateringen misslyckades. Visar senast hämtade data om de finns.",
connection_stale: "Statistiken kan vara inaktuell. Uppdatering väntar; avsluta eventuell inmatning.",
connection_last: "Senast hämtad {time}.",
connection_retry: "Försök igen",
connection_retrying: "Hämtar...",
loading: "Laddar träningsprofil...",
loadError: "Kunde inte läsa träningsprofilen. Länken kan vara avstängd eller ersatt.",
development: "Förarutveckling",
class: "Klass",
layoutStats: "Banlayout",
lapSource: "Underlag",
lapSourcePractice: "Träning",
lapSourceRace: "Race 🏁",
lapSourceAll: "Alla",
layoutCurrent: "Aktiv layout",
layoutNone: "Utan layout (före första layouten)",
layoutAll: "Alla layouter",
laps: "Totala varv",
days: "Träningsdagar",
best: "Bästa varv",
consistency: "Jämnhet senaste 30",
nextLevel: "Nästa nivå",
reachLaps: "Nå {laps} varv",
reachSessions: "Genomför {count} pass",
lapsRemaining: "{laps} varv kvar",
timerSessionTitle: "Träningspass",
exerciseHistoryTitle: "Träningshistorik",
exerciseHistoryHint: "Genomförda träningspass - jämna varv, stegträning och vanliga pass - för att se utvecklingen över tid.",
exerciseHistoryEmpty: "Inga genomförda träningspass ännu.",
exerciseHistoryEvenLaps: "Serie på {streak} varv i mål {lap}",
exerciseHistoryStepTraining: "{steps} steg, {laps} varv",
exerciseHistoryTimer: "{laps} varv, snitt {lap}",
exerciseSessionsCredit: "Du har genomfört {count} träningspass idag - snyggt jobbat!",
plan: "Dagens träningspass",
timerSetup: "Ställ in passet",
pushMinutes: "Maxfokus (min)",
controlMinutes: "Kontrollerad (min)",
timerSetupHint: "Minst ett block måste vara 1 minut. Tiderna sparas för den här föraren och klassen.",
timerLockedHint: "Nollställ eller slutför passet för att ändra tiderna.",
sessionStats: "Det här passet",
sessionLaps: "Varv",
baselineTitle: "Bygg en baslinje",
baselineBody: "Kör lugnt och jämnt tills du har minst 10 rena varv. Upprepa samma linje och bromspunkt.",
consistencyTitle: "Höj din lägstanivå",
consistencyBody: "Kör första blocket nära max, sedan ett kontrollerat block på 80-90 procent med fokus på rena, repeterbara varv.",
progressionTitle: "Balansera fart och kontroll",
progressionBody: "Kör ett block med maxfokus och avsluta med ett kontrollerat block utan misstag.",
target: "Kontrollmål {lap}",
ready: "Redo att börja",
push: "Maxfokus: hitta gränsen",
control: "80-90%: höj lägstanivån",
finished: "Passet är klart",
start: "Starta pass",
pause: "Pausa",
resume: "Fortsätt",
running: "Pågår",
reset: "Nollställ",
goals: "Mål och belöningar",
noGoals: "Inga personliga mål har lagts till ännu.",
goalReached: "Målet är nått",
rewardDelivered: "Belöning utdelad",
reward: "Belöning",
history: "Senaste träningsdagar",
date: "Datum",
dayLaps: "Varv",
average: "Snitt",
updated: "Uppdaterad {time}",
switchCue: "Byt till kontrollerad körning",
finishCue: "Träningspasset är klart",
practiceSummaryTitle: "Pass avslutat",
practiceSummaryNoLaps: "Inga varv registrerades under passet - kolla att transpondern fungerade och kör igen.",
practiceSummaryPaceFaster: "Du körde i snitt {lap} snabbare än innan.",
practiceSummaryPaceSlower: "Du körde i snitt {lap} långsammare än innan - ingen fara, alla pass är olika.",
practiceSummaryPaceStable: "Ditt tempo var i linje med tidigare pass.",
practiceSummaryPaceInsufficient: "Kör några fler pass så kan vi visa hur ditt tempo utvecklas.",
practiceSummaryConsistencyGood: "Mycket jämna varv den här gången ({pct}%).",
practiceSummaryConsistencyOk: "Ganska jämna varv ({pct}%).",
practiceSummaryConsistencyRough: "Varven varierade en del ({pct}%) - sikta på jämnare tempo nästa gång.",
practiceSummaryConsistencyInsufficient: "För få varv den här passet för att bedöma jämnheten.",
practiceSummaryGoalReached: "Du nådde \"{title}\" ({laps} varv)!",
practiceSummaryMilestoneReached: "Du passerade {laps} varv totalt!",
practiceSummaryRewardHint: "Belöning: {reward} - visa den här sidan för din coach eller förälder.",
practiceSummaryNextGoalTitle: "Nästa mål",
practiceSummaryClose: "Stäng",
performance: "Stintstatistik",
paceChart: "Tempoutveckling",
paceChartHint: "Senaste träningsdagarnas snittempo i vald klass. Lägre är snabbare.",
stintDetails: "Senaste stintar",
stintNumber: "Stint",
duration: "Tid",
noStints: "Inga stintar registrerade ännu.",
paceBlocks: "Tempo per aktivt 30-minutersblock",
paceBlocksHint: "Visar bara block där bilen har registrerat giltiga varv.",
markerTitle: "Markera en biländring",
markerHint: "Sparas för vald förare och klass vid aktuell tid.",
markerType: "Typ", markerNote: "Beskrivning", markerSave: "Markera ändring nu",
markerSetup: "Ny setup", markerTires: "Däck", markerSuspension: "Dämpare", markerCar: "Bil", markerNoteType: "Anteckning",
markerSaved: "Biländringen är sparad.", markerError: "Kunde inte spara biländringen.",
blockLaps: "{laps} varv", blockMarkers: "{count} ändring(ar)",
evenLapsTitle: "Jämna varv", evenLapsEyebrow: "Övning",
evenLapsHint: "Ställ in måltid och tolerans, spara, och starta när du är redo att köra.",
evenLapsTargetLabel: "Måltid (sek)", evenLapsToleranceLabel: "Tolerans ± (sek)", evenLapsLapCountLabel: "Antal varv i serien",
evenLapsSuggestionHint: "Förslag baserat på ditt bästa varv: {lap}",
evenLapsStreak: "{current}/{target} jämna varv", evenLapsNewStreak: "Ny serie – försök slå din bästa",
evenLapsStartHint: "Kör ditt första varv för att starta en serie.",
evenLapsBestTodayLabel: "Bästa serie idag", evenLapsNotStarted: "Inte startad ännu.",
stepTrainingTitle: "Stegträning", stepTrainingEyebrow: "Övning",
stepTrainingHint: "Bygg din stegserie, spara, och starta när du är redo. Standard är pyramiden: lugnt, kontrollerat, snabbt, kontrollerat, lugnt.",
stepTrainingComplete: "Serien klar – bra jobbat!",
stepTrainingCurrent: "Steg {step}/{total}: {effort}", stepTrainingRemaining: "{laps} varv kvar",
stepTrainingCompare: "Kontrollerat steg 1: {first} · Kontrollerat steg 2: {last} ({diff})",
stepTrainingNotStarted: "Inte startad ännu.",
effortCalm: "Lugnt", effortControlled: "Kontrollerat", effortFast: "Snabbt",
saveSetup: "Spara", stop: "Stoppa",
stints: "Stints",
bestThree: "Bästa 3 sammanhängande",
bestFive: "Bästa 5 min",
fiveAverage: "Avg pace, bästa 5 min",
splitPassings: "Mellantidspasseringar",
bestSplit: "Bästa mellantid",
latestSectorGain: "Senaste sektorförbättring",
controlZone: "Kontrollzon",
outlierLaps: "Avvikande varv",
strongFinishes: "Starka avslutningar",
pitStops: "Depåstopp",
totalPit: "Total depåtid",
recentProgress: "Din senaste utveckling",
averagePace: "Snittempo",
collectingTrend: "Samlar jämförbart underlag",
fasterTrend: "{lap} snabbare per varv",
slowerTrend: "{lap} långsammare just nu",
stableTrend: "Stabil nivå",
achievements: "Achievements",
unlocked: "Upplåst",
nextAchievement: "Nästa delmål",
achievement_first_session: "Första träningspasset",
achievement_laps_100: "100 träningsvarv",
achievement_laps_250: "250 träningsvarv",
achievement_laps_500: "500 träningsvarv",
achievement_laps_1000: "1 000 träningsvarv",
achievement_laps_1500: "1 500 träningsvarv",
achievement_days_3: "3 träningsdagar",
achievement_days_10: "10 träningsdagar",
achievement_sessions_5: "5 fullföljda träningspass",
achievement_controlled_5: "5 kontrollerade varv i rad",
achievement_controlled_10: "10 kontrollerade varv i rad",
achievement_five_minute: "Fullföljd femminutersstint",
achievement_five_minutes_3: "3 fullföljda femminutersstintar",
achievement_consistency_5: "Jämnhet under 5 procent",
achievement_strong_finish: "Stark avslutning",
achievement_clean_five_minute: "Fem minuter utan avvikande varv",
achievement_pace_gain: "Förbättrat snittempo",
creditTitle: "Din träning räknas",
creditBody: "Varje genomfört varv bygger erfarenhet. Du jämförs med din egen utveckling, inte med andra förare.",
todayLapsCredit: "{laps} giltiga varv idag",
paceCredit: "Snittempot är {lap} snabbare per varv",
consistencyCredit: "{value} procentenheter jämnare körning",
controlledCredit: "{laps} kontrollerade varv i rad",
fiveMinuteCredit: "Du har fullföljt en femminutersstint",
sectorCredit: "Sektortiden förbättrad med {lap}",
strongFinishCredit: "Stark avslutning med bibehållet tempo",
cleanFiveCredit: "Fem minuter utan avvikande varv",
buildingCredit: "{laps} varv har redan byggt din erfarenhet",
readyCredit: "Första giltiga varvet startar din utvecklingsresa",
challenges: "Små utmaningar",
challengesHint: "Valfria mål som ger kredit för mängd, kontroll och uthållighet.",
challengeLaps: "Samla 20 varv idag",
challengeControlled: "Kör 5 kontrollerade varv i rad",
challengeFive: "Fullfölj en femminutersstint",
challengeProgress: "{current} / {target}",
},
en: {
connection_loading: "Loading statistics...",
connection_current: "Statistics are up to date.",
connection_failed: "Update failed. Showing previously loaded data if available.",
connection_stale: "Statistics may be outdated. Update pending; finish any active input.",
connection_last: "Last loaded {time}.",
connection_retry: "Retry",
connection_retrying: "Loading...",
loading: "Loading training profile...",
loadError: "The training profile could not be loaded. The link may be disabled or replaced.",
development: "Driver development",
class: "Class",
layoutStats: "Track layout",
lapSource: "Based on",
lapSourcePractice: "Practice",
lapSourceRace: "Races 🏁",
lapSourceAll: "All",
layoutCurrent: "Current layout",
layoutNone: "No layout (before the first layout)",
layoutAll: "All layouts",
laps: "Total laps",
days: "Practice days",
best: "Best lap",
consistency: "Latest 30 consistency",
nextLevel: "Next level",
reachLaps: "Reach {laps} laps",
reachSessions: "Complete {count} sessions",
lapsRemaining: "{laps} laps remaining",
timerSessionTitle: "Practice session",
exerciseHistoryTitle: "Training history",
exerciseHistoryHint: "Completed training sessions - even laps, step training and regular sessions - to see progress over time.",
exerciseHistoryEmpty: "No completed training sessions yet.",
exerciseHistoryEvenLaps: "{streak}-lap streak at target {lap}",
exerciseHistoryStepTraining: "{steps} steps, {laps} laps",
exerciseHistoryTimer: "{laps} laps, average {lap}",
exerciseSessionsCredit: "You completed {count} training session(s) today - nice work!",
plan: "Today's practice session",
timerSetup: "Set session duration",
pushMinutes: "Maximum focus (min)",
controlMinutes: "Controlled (min)",
timerSetupHint: "At least one block must be 1 minute. Times are saved for this driver and class.",
timerLockedHint: "Reset or finish the session to change the times.",
sessionStats: "This session",
sessionLaps: "Laps",
baselineTitle: "Build a baseline",
baselineBody: "Drive calmly and consistently until at least 10 clean laps are recorded. Repeat the same line and braking point.",
consistencyTitle: "Raise your minimum level",
consistencyBody: "Run the first block near maximum pace, then a controlled block at 80-90 percent with clean, repeatable laps.",
progressionTitle: "Balance pace and control",
progressionBody: "Run one block at maximum focus and finish with a controlled block without mistakes.",
target: "Control target {lap}",
ready: "Ready to start",
push: "Maximum focus: find the limit",
control: "80-90%: raise the floor",
finished: "Session completed",
start: "Start session",
pause: "Pause",
resume: "Resume",
running: "Running",
reset: "Reset",
goals: "Goals and rewards",
noGoals: "No personal goals have been added yet.",
goalReached: "Goal reached",
rewardDelivered: "Reward delivered",
reward: "Reward",
history: "Latest practice days",
date: "Date",
dayLaps: "Laps",
average: "Average",
updated: "Updated {time}",
switchCue: "Switch to controlled driving",
finishCue: "The training session is complete",
practiceSummaryTitle: "Practice complete",
practiceSummaryNoLaps: "No laps were recorded during this pass - check the transponder and try again.",
practiceSummaryPaceFaster: "You averaged {lap} faster than before.",
practiceSummaryPaceSlower: "You averaged {lap} slower than before - that's fine, every pass is different.",
practiceSummaryPaceStable: "Your pace matched your recent sessions.",
practiceSummaryPaceInsufficient: "Run a few more sessions and we can show how your pace is developing.",
practiceSummaryConsistencyGood: "Very even laps this time ({pct}%).",
practiceSummaryConsistencyOk: "Fairly even laps ({pct}%).",
practiceSummaryConsistencyRough: "Your laps varied a bit ({pct}%) - aim for a steadier pace next time.",
practiceSummaryConsistencyInsufficient: "Not enough laps this pass to judge consistency.",
practiceSummaryGoalReached: "You reached \"{title}\" ({laps} laps)!",
practiceSummaryMilestoneReached: "You passed {laps} total laps!",
practiceSummaryRewardHint: "Reward: {reward} - show this page to your coach or parent.",
practiceSummaryNextGoalTitle: "Next goal",
practiceSummaryClose: "Close",
performance: "Stint statistics",
paceChart: "Pace development",
paceChartHint: "Average pace for recent practice days in the selected class. Lower is faster.",
stintDetails: "Recent stints",
stintNumber: "Stint",
duration: "Duration",
noStints: "No stints have been recorded yet.",
paceBlocks: "Pace per active 30-minute block",
paceBlocksHint: "Only blocks containing valid recorded laps are shown.",
markerTitle: "Mark a car change",
markerHint: "Saved for the selected driver and class at the current time.",
markerType: "Type", markerNote: "Description", markerSave: "Mark change now",
markerSetup: "New setup", markerTires: "Tires", markerSuspension: "Suspension", markerCar: "Car", markerNoteType: "Note",
markerSaved: "The car change was saved.", markerError: "The car change could not be saved.",
blockLaps: "{laps} laps", blockMarkers: "{count} change(s)",
evenLapsTitle: "Even laps", evenLapsEyebrow: "Exercise",
evenLapsHint: "Set a target and tolerance, save, and start when you're ready to run.",
evenLapsTargetLabel: "Target (sec)", evenLapsToleranceLabel: "Tolerance ± (sec)", evenLapsLapCountLabel: "Laps in the streak",
evenLapsSuggestionHint: "Suggested from your best lap: {lap}",
evenLapsStreak: "{current}/{target} even laps", evenLapsNewStreak: "New streak - try to beat your best",
evenLapsStartHint: "Run your first lap to start a streak.",
evenLapsBestTodayLabel: "Best streak today", evenLapsNotStarted: "Not started yet.",
stepTrainingTitle: "Step training", stepTrainingEyebrow: "Exercise",
stepTrainingHint: "Build your step sequence, save, and start when ready. The default is the pyramid: calm, controlled, fast, controlled, calm.",
stepTrainingComplete: "Sequence complete - nice work!",
stepTrainingCurrent: "Step {step}/{total}: {effort}", stepTrainingRemaining: "{laps} laps remaining",
stepTrainingCompare: "Controlled step 1: {first} · Controlled step 2: {last} ({diff})",
stepTrainingNotStarted: "Not started yet.",
effortCalm: "Calm", effortControlled: "Controlled", effortFast: "Fast",
saveSetup: "Save", stop: "Stop",
stints: "Stints",
bestThree: "Best 3 consecutive",
bestFive: "Best 5 min",
fiveAverage: "Average pace, best 5 min",
splitPassings: "Split passings",
bestSplit: "Best split",
latestSectorGain: "Latest sector improvement",
controlZone: "Control zone",
outlierLaps: "Outlier laps",
strongFinishes: "Strong finishes",
pitStops: "Pit stops",
totalPit: "Total pit time",
recentProgress: "Your recent development",
averagePace: "Average pace",
collectingTrend: "Collecting comparable data",
fasterTrend: "{lap} faster per lap",
slowerTrend: "{lap} slower right now",
stableTrend: "Stable level",
achievements: "Achievements",
unlocked: "Unlocked",
nextAchievement: "Next milestone",
achievement_first_session: "First practice session",
achievement_laps_100: "100 practice laps",
achievement_laps_250: "250 practice laps",
achievement_laps_500: "500 practice laps",
achievement_laps_1000: "1,000 practice laps",
achievement_laps_1500: "1,500 practice laps",
achievement_days_3: "3 practice days",
achievement_days_10: "10 practice days",
achievement_sessions_5: "5 completed practice sessions",
achievement_controlled_5: "5 controlled laps in a row",
achievement_controlled_10: "10 controlled laps in a row",
achievement_five_minute: "Completed five-minute stint",
achievement_five_minutes_3: "3 completed five-minute stints",
achievement_consistency_5: "Consistency below 5 percent",
achievement_strong_finish: "Strong finish",
achievement_clean_five_minute: "Five minutes without outlier laps",
achievement_pace_gain: "Improved average pace",
creditTitle: "Your practice counts",
creditBody: "Every completed lap builds experience. You are compared with your own development, not other drivers.",
todayLapsCredit: "{laps} valid laps today",
paceCredit: "Average pace is {lap} faster per lap",
consistencyCredit: "{value} percentage points more consistent",
controlledCredit: "{laps} controlled laps in a row",
fiveMinuteCredit: "You completed a five-minute stint",
sectorCredit: "Sector time improved by {lap}",
strongFinishCredit: "Strong finish with pace maintained",
cleanFiveCredit: "Five minutes without outlier laps",
buildingCredit: "{laps} laps have already built your experience",
readyCredit: "Your first valid lap starts the development journey",
challenges: "Small challenges",
challengesHint: "Optional goals that recognize volume, control, and endurance.",
challengeLaps: "Collect 20 laps today",
challengeControlled: "Run 5 controlled laps in a row",
challengeFive: "Complete a five-minute stint",
challengeProgress: "{current} / {target}",
},
};
let profileData = null;
let timerHandle = null;
let lastTimerPhase = "";
function t(key, vars = {}) {
const template = messages[language]?.[key] || messages.en[key] || key;
return String(template).replace(/\{(\w+)\}/g, (_, name) => String(vars[name] ?? ""));
}
function escapeHtml(value) {
return String(value ?? "")
.replaceAll("&", "&")
.replaceAll("<", "<")
.replaceAll(">", ">")
.replaceAll('"', """)
.replaceAll("'", "'");
}
function formatLap(ms) {
const value = Math.max(0, Number(ms || 0));
if (!value) return "-";
const minutes = Math.floor(value / 60000);
const seconds = Math.floor((value % 60000) / 1000);
const millis = Math.floor(value % 1000);
return `${minutes}:${String(seconds).padStart(2, "0")}.${String(millis).padStart(3, "0")}`;
}
function formatRaceResultTime(ms) {
const value = Math.max(0, Math.floor(Number(ms || 0)));
const minutes = Math.floor(value / 60000);
const seconds = Math.floor((value % 60000) / 1000);
const centiseconds = Math.floor((value % 1000) / 10);
const millis = Math.floor(value % 1000);
return `${String(minutes).padStart(2, "0")}:${String(seconds).padStart(2, "0")}.${String(centiseconds).padStart(2, "0")}:${String(millis).padStart(3, "0")}`;
}
function formatTimer(ms) {
const seconds = Math.max(0, Math.ceil(ms / 1000));
return `${String(Math.floor(seconds / 60)).padStart(2, "0")}:${String(seconds % 60).padStart(2, "0")}`;
}
function recommendationCopy(recommendation) {
const level = ["baseline", "consistency", "progression"].includes(recommendation?.level) ? recommendation.level : "baseline";
return {
title: t(`${level}Title`),
body: t(`${level}Body`),
};
}
function exerciseKindMeta(kind) {
if (kind === "evenLaps") return { emoji: "🎯", titleKey: "evenLapsTitle" };
if (kind === "stepTraining") return { emoji: "🪜", titleKey: "stepTrainingTitle" };
return { emoji: "⏱️", titleKey: "timerSessionTitle" };
}
function nextMilestoneForLaps(laps) {
const presets = [100, 250, 500, 1000, 1500, 2500, 5000];
return presets.find((target) => target > laps) || (Math.floor(laps / 1000) + 1) * 1000;
}
// Turns the already-fetched, already-sanitized profile data into a one-time "practice just
// ended" recap: pace and consistency for this pass specifically, anything crossed *during*
// this pass (not all-time), one suggested next goal, and the reward text made prominent -
// never a comparison against other drivers.
function buildPracticeSummary({ currentSession, stats, goals, recommendation, nextMilestone }) {
const laps = currentSession?.laps || 0;
if (!laps) return { laps: 0, paceText: t("practiceSummaryNoLaps"), consistencyText: "", justReachedGoals: [], justReachedMilestoneLaps: null, nextGoalTitle: "", nextGoalBody: "" };
const paceText = !stats.trendSampleReady || laps < 3
? t("practiceSummaryPaceInsufficient")
: (() => {
const diffMs = Number(stats.previousRecentAverageMs || 0) - Number(currentSession.averageLapMs || 0);
if (Math.abs(diffMs) < 50) return t("practiceSummaryPaceStable");
return diffMs > 0
? t("practiceSummaryPaceFaster", { lap: formatLap(diffMs) })
: t("practiceSummaryPaceSlower", { lap: formatLap(Math.abs(diffMs)) });
})();
const consistencyText = !currentSession.consistencySampleReady
? t("practiceSummaryConsistencyInsufficient")
: (() => {
const pct = Number(currentSession.consistencySpreadPct || 0);
const key = pct <= 5 ? "practiceSummaryConsistencyGood" : pct <= 8 ? "practiceSummaryConsistencyOk" : "practiceSummaryConsistencyRough";
return t(key, { pct: pct.toFixed(1) });
})();
const lapsBeforeSession = Math.max(0, Number(stats.totalLaps || 0) - laps);
const justReachedGoals = (Array.isArray(goals) ? goals : []).filter((goal) => goal.reached && lapsBeforeSession < goal.targetLaps);
const milestoneBeforeTarget = nextMilestoneForLaps(lapsBeforeSession);
const justReachedMilestoneLaps = milestoneBeforeTarget <= Number(stats.totalLaps || 0) ? milestoneBeforeTarget : null;
const recommendationText = recommendationCopy(recommendation);
const useMilestoneAsNextGoal = recommendation?.level === "baseline" && nextMilestone?.remainingLaps;
const nextGoalTitle = useMilestoneAsNextGoal ? t("reachLaps", { laps: nextMilestone.targetLaps }) : recommendationText.title;
const nextGoalBody = useMilestoneAsNextGoal ? t("lapsRemaining", { laps: nextMilestone.remainingLaps }) : recommendationText.body;
return { laps, paceText, consistencyText, justReachedGoals, justReachedMilestoneLaps, nextGoalTitle, nextGoalBody };
}
function getLocalDayKey(timestamp) {
const date = new Date(Number(timestamp || 0));
if (Number.isNaN(date.getTime())) return "";
return `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, "0")}-${String(date.getDate()).padStart(2, "0")}`;
}
function buildProfileMotivation(stats, channelStats = {}, exerciseSessionHistory = []) {
const todayKey = getLocalDayKey(Date.now());
const today = (Array.isArray(stats?.dailySummaries) ? stats.dailySummaries : []).find((day) => day.dateKey === todayKey);
const exerciseSessionsToday = (Array.isArray(exerciseSessionHistory) ? exerciseSessionHistory : [])
.filter((entry) => getLocalDayKey(new Date(entry.completedAt).getTime()) === todayKey);
const activeToday = Boolean(today);
const todayLaps = Number(today?.laps || 0);
const controlled = activeToday ? Number(stats?.todayControlledLapStreak || 0) : 0;
const completedFive = activeToday ? Number(stats?.todayCompletedFiveMinuteStints || 0) : 0;
const challenges = [
{ id: "Laps", current: todayLaps, target: 20 },
{ id: "Controlled", current: controlled, target: 5 },
{ id: "Five", current: completedFive, target: 1 },
].map((challenge) => ({
...challenge,
percent: Math.min(100, Math.max(0, (challenge.current / challenge.target) * 100)),
completed: challenge.current >= challenge.target,
}));
const credits = [];
// Completing a guided exercise pass is worth calling out first - it's the thing the driver
// most deliberately chose to do, not just background pace/consistency drift.
if (exerciseSessionsToday.length) credits.push(t("exerciseSessionsCredit", { count: exerciseSessionsToday.length }));
if (todayLaps) credits.push(t("todayLapsCredit", { laps: todayLaps }));
if (stats?.trendSampleReady && Number(stats.averageTrendMs || 0) > 0) credits.push(t("paceCredit", { lap: formatLap(stats.averageTrendMs) }));
if (stats?.trendSampleReady && Number(stats.consistencyTrendPct || 0) > 0.1) credits.push(t("consistencyCredit", { value: Number(stats.consistencyTrendPct).toFixed(1) }));
if (controlled >= 5) credits.push(t("controlledCredit", { laps: controlled }));
if (completedFive) credits.push(t("fiveMinuteCredit"));
if (Number(channelStats.latestSplitGainMs || 0) > 0) credits.push(t("sectorCredit", { lap: formatLap(channelStats.latestSplitGainMs) }));
if (Number(stats?.todayStrongFinishStints || 0) > 0) credits.push(t("strongFinishCredit"));
if (Number(stats?.todayCleanFiveMinuteStints || 0) > 0) credits.push(t("cleanFiveCredit"));
if (!credits.length && Number(stats?.totalLaps || 0) > 0) credits.push(t("buildingCredit", { laps: stats.totalLaps }));
if (!credits.length) credits.push(t("readyCredit"));
return { challenges, credits: credits.slice(0, 3) };
}
function renderPaceChart(points) {
const values = (Array.isArray(points) ? points : []).slice().reverse().filter((point) => Number(point.averageLapMs || 0) > 0);
if (values.length < 2) return `
${escapeHtml(t("collectingTrend"))}
`;
const width = 640, height = 180, padding = 24;
const lapTimes = values.map((point) => Number(point.averageLapMs));
const min = Math.min(...lapTimes);
const range = Math.max(1, Math.max(...lapTimes) - min);
const coordinates = values.map((point, index) => ({ x: padding + (index / Math.max(1, values.length - 1)) * (width - padding * 2), y: padding + ((Number(point.averageLapMs) - min) / range) * (height - padding * 2), point }));
const path = coordinates.map((point) => `${point.x.toFixed(1)},${point.y.toFixed(1)}`).join(" ");
return `${escapeHtml(values[0].dateKey)}${escapeHtml(formatLap(values.at(-1).averageLapMs))}${escapeHtml(values.at(-1).dateKey)}
`;
}
const markerDrafts = new Map();
function profileIsBeingEdited() {
return (root.contains(document.activeElement) && document.activeElement.matches("input, select, textarea"))
|| Boolean(root.querySelector("#publicTrainingMarkerForm button:disabled"));
}
function renderProfile(data) {
const previousForm = root.querySelector("#publicTrainingMarkerForm");
if (previousForm) {
const values = new FormData(previousForm);
markerDrafts.set(previousForm.dataset.classId, { type: values.get("type"), note: values.get("note") });
}
const openSections = new Set([...root.querySelectorAll("details[data-persist-open][open]")].map((element) => element.dataset.persistOpen));
profileData = data;
const { profile, branding } = data;
const visibility = { progress: true, achievements: true, performance: true, goals: true, history: true, ...(data.visibility || {}) };
const classProfiles = Array.isArray(data.classProfiles) ? data.classProfiles : [];
let activeClass = classProfiles.find((item) => String(item.classId || "") === selectedClassId) || classProfiles[0] || null;
if (activeClass && selectedClassId !== activeClass.classId) selectedClassId = activeClass.classId;
const stats = { dailySummaries: [], paceHistory: [], achievements: [], stintSummaries: [], ...(activeClass?.stats || data.stats || {}) };
const channelStats = activeClass?.channelStats || data.channelStats || {};
const nextMilestone = activeClass?.nextMilestone || data.nextMilestone;
const recommendation = activeClass?.recommendation || data.recommendation;
const goals = activeClass?.goals || data.goals || [];
const currentSession = activeClass?.currentSession || data.currentSession;
const evenLapsConfig = activeClass?.evenLapsConfig || null;
const evenLapsProgress = activeClass?.evenLapsProgress || null;
const evenLapsSuggestedTargetMs = stats.bestLapMs ? Math.round(stats.bestLapMs * 1.05) : 0;
const evenLapsRun = readExerciseRunState("evenlaps");
const evenLapsRunning = Boolean(evenLapsRun);
const stepTrainingConfig = activeClass?.stepTrainingConfig || null;
const stepTrainingProgress = activeClass?.stepTrainingProgress || null;
const stepTrainingRun = readExerciseRunState("steptraining");
const stepTrainingRunning = Boolean(stepTrainingRun);
const exerciseSessionHistory = activeClass?.exerciseSessionHistory || data.exerciseSessionHistory || [];
if (evenLapsRun && evenLapsConfig && evenLapsProgress?.currentStreak >= evenLapsConfig.lapCount) {
void maybeRecordExerciseCompletion("evenLaps", evenLapsRun.startedAt);
}
if (stepTrainingRun && stepTrainingProgress?.complete) {
void maybeRecordExerciseCompletion("stepTraining", stepTrainingRun.startedAt);
}
const defaultStepTrainingRows = [
{ effort: "calm", lapCount: 5 }, { effort: "controlled", lapCount: 5 }, { effort: "fast", lapCount: 5 },
{ effort: "controlled", lapCount: 5 }, { effort: "calm", lapCount: 5 },
];
const stepTrainingFormRows = stepTrainingConfig?.steps?.length
? [...stepTrainingConfig.steps, ...Array(Math.max(0, 5 - stepTrainingConfig.steps.length)).fill({ effort: "calm", lapCount: 0 })].slice(0, 5)
: defaultStepTrainingRows;
const motivation = buildProfileMotivation(stats, channelStats, exerciseSessionHistory);
const recommendationText = recommendationCopy(recommendation);
const timerState = readTimerState();
const timerConfig = getTimerConfig(timerState);
const timerDurationMs = getTimerDurationMs(timerConfig);
const timerLocked = Boolean(timerState?.startedAt && getTimerElapsed(timerState) < timerDurationMs);
const timerJustFinished = Boolean(timerState?.startedAt && getTimerElapsed(timerState) >= timerDurationMs);
const showPracticeSummary = timerJustFinished && String(timerState.startedAt) !== readPracticeSummaryDismissedFor();
const practiceSummary = showPracticeSummary ? buildPracticeSummary({ currentSession, stats, goals, recommendation, nextMilestone }) : null;
const achievements = Array.isArray(stats.achievements) ? stats.achievements : [];
const unlockedAchievements = achievements.filter((achievement) => achievement.unlocked);
const nextAchievement = achievements.find((achievement) => !achievement.unlocked);
const visibleAchievements = [...unlockedAchievements.slice(-5), ...(nextAchievement ? [nextAchievement] : [])];
const achievementMarkup = visibleAchievements.map((achievement) => `
${achievement.unlocked ? "OK" : `${Math.round(Number(achievement.percent || 0))}%`}
${escapeHtml(t(`achievement_${achievement.id}`))}${escapeHtml(t(achievement.unlocked ? "unlocked" : "nextAchievement"))}
`).join("");
const creditMarkup = motivation.credits.map((credit) => `+${escapeHtml(credit)}`).join("");
const challengeMarkup = motivation.challenges.map((challenge) => `
${challenge.completed ? "OK" : `${Math.round(challenge.percent)}%`}
${escapeHtml(t(`challenge${challenge.id}`))}
${escapeHtml(t("challengeProgress", { current: challenge.current, target: challenge.target }))}
`).join("");
const paceTrend = !stats.trendSampleReady
? t("collectingTrend")
: stats.averageTrendMs > 0
? t("fasterTrend", { lap: formatLap(stats.averageTrendMs) })
: stats.averageTrendMs < 0
? t("slowerTrend", { lap: formatLap(Math.abs(stats.averageTrendMs)) })
: t("stableTrend");
const logo = /^data:image\/(?:png|jpeg|webp);base64,/i.test(branding.logoDataUrl || "")
? `
`
: `RC
`;
const goalMarkup = goals.length
? goals.map((goal) => {
const isSessions = goal.metric === "sessions";
const meta = exerciseKindMeta(goal.exerciseKind);
const unitSuffix = isSessions ? ` ${meta.emoji} ${escapeHtml(t(meta.titleKey))}` : "";
return `
${escapeHtml(goal.title || (isSessions ? t("reachSessions", { count: goal.targetLaps }) : t("reachLaps", { laps: goal.targetLaps })))}
${goal.currentLaps} / ${goal.targetLaps}${unitSuffix}
${goal.reward ? `${escapeHtml(t("reward"))}
${escapeHtml(goal.reward)}
` : ""}
${goal.claimed ? `${escapeHtml(t("rewardDelivered"))}` : goal.reached ? `${escapeHtml(t("goalReached"))}` : ""}
`;
}).join("")
: `${escapeHtml(t("noGoals"))}
`;
const historyRows = stats.dailySummaries.length
? stats.dailySummaries.slice(0, 12).map((day) => `
| ${escapeHtml(new Date(day.latestTimestamp).toLocaleDateString(language))} |
${day.laps} |
${formatLap(day.bestLapMs)} |
${formatLap(day.averageLapMs)} |
`).join("")
: `| - |
`;
const paceBuckets = Array.isArray(stats.paceBuckets) ? stats.paceBuckets : [];
const paceBucketMarkup = paceBuckets.length ? paceBuckets.map((bucket) => `${escapeHtml(new Date(bucket.startTs).toLocaleString(language, { dateStyle: "short", timeStyle: "short" }))}${formatLap(bucket.paceMs)}${escapeHtml(t("blockLaps", { laps: bucket.lapCount }))} · PB ${formatLap(bucket.bestLapMs)}${bucket.markerCount ? " · " + escapeHtml(t("blockMarkers", { count: bucket.markerCount })) : ""}`).join("") : `-
`;
const stintRows = stats.stintSummaries.length ? stats.stintSummaries.slice(0, 6).map((stint) => `
| ${stint.number} | ${escapeHtml(new Date(stint.startedAt).toLocaleString(language, { dateStyle: "short", timeStyle: "short" }))} | ${stint.lapCount} | ${formatLap(stint.bestLapMs)} | ${formatLap(stint.averageLapMs)} | ${formatRaceResultTime(stint.durationMs)} |
`).join("") : `| ${escapeHtml(t("noStints"))} |
`;
const classOptions = classProfiles.map((item) => (
``
)).join("");
document.documentElement.lang = language;
document.title = `${profile.name} - ${branding.clubName}`;
root.innerHTML = `
${escapeHtml(t("development"))}
${escapeHtml(profile.name)}
${classProfiles.length > 1 ? `` : activeClass?.className ? `${escapeHtml(activeClass.className)}` : ""}
${activeClass?.brand ? `${escapeHtml(activeClass.brand)}` : ""}
${renderLayoutSelect(data.trackLayouts)}
${renderSourceSelect(data.lapSource)}
${renderStat(t("laps"), stats.totalLaps)}
${renderStat(t("days"), stats.trainingDays)}
${renderStat(t("best"), formatLap(stats.bestLapMs))}
${renderStat(t("consistency"), stats.recentLapCount ? `${Number(stats.consistencySpreadPct).toFixed(1)}%` : "-")}
${escapeHtml(t("creditTitle"))}
${escapeHtml(t("creditBody"))}
${escapeHtml(t("challenges"))}${motivation.challenges.filter((challenge) => challenge.completed).length}/${motivation.challenges.length}
${escapeHtml(t("challengesHint"))}
${challengeMarkup}
${escapeHtml(t("recentProgress"))}
${escapeHtml(t("averagePace"))}
${escapeHtml(paceTrend)}
${escapeHtml(t("achievements"))}${unlockedAchievements.length}/${achievements.length}
${achievementMarkup}
${escapeHtml(t("paceChart"))}
${escapeHtml(t("paceChartHint"))}
${renderPaceChart(stats.paceHistory)}
${escapeHtml(t("nextLevel"))}
${escapeHtml(t("lapsRemaining", { laps: nextMilestone.remainingLaps }))}
${escapeHtml(t("reachLaps", { laps: nextMilestone.targetLaps }))}
${nextMilestone.currentLaps} / ${nextMilestone.targetLaps}
${escapeHtml(t("plan"))}
${recommendation.targetLapMs ? escapeHtml(t("target", { lap: formatLap(recommendation.targetLapMs) })) : ""}
${escapeHtml(recommendationText.title)}
${escapeHtml(recommendationText.body)}
${formatTimer(timerDurationMs)}
${escapeHtml(t("ready"))}
${currentSession ? `
${escapeHtml(t("sessionStats"))}
${escapeHtml(t("sessionLaps"))}${currentSession.laps}
${escapeHtml(t("best"))}${formatLap(currentSession.bestLapMs)}
${escapeHtml(t("average"))}${formatLap(currentSession.averageLapMs)}
` : ""}
${practiceSummary ? `
${escapeHtml(t("practiceSummaryTitle"))}
${practiceSummary.laps ? `
${escapeHtml(t("sessionLaps"))}: ${practiceSummary.laps}
${escapeHtml(practiceSummary.paceText)}
${escapeHtml(practiceSummary.consistencyText)}
${practiceSummary.justReachedMilestoneLaps ? `
${escapeHtml(t("practiceSummaryMilestoneReached", { laps: practiceSummary.justReachedMilestoneLaps }))}
` : ""}
${practiceSummary.justReachedGoals.map((goal) => `
${escapeHtml(t("practiceSummaryGoalReached", { title: goal.title || t("reachLaps", { laps: goal.targetLaps }), laps: goal.targetLaps }))}
${goal.reward ? `
${escapeHtml(t("practiceSummaryRewardHint", { reward: goal.reward }))}
` : ""}
`).join("")}
${escapeHtml(t("practiceSummaryNextGoalTitle"))}
${escapeHtml(practiceSummary.nextGoalTitle)}
${escapeHtml(practiceSummary.nextGoalBody)}
` : `
${escapeHtml(practiceSummary.paceText)}
`}
` : ""}
${escapeHtml(t("evenLapsEyebrow"))}
${escapeHtml(t("evenLapsTitle"))}
${evenLapsConfig && evenLapsProgress?.active ? `
${escapeHtml(evenLapsProgress.currentStreak > 0
? t("evenLapsStreak", { current: evenLapsProgress.currentStreak, target: evenLapsConfig.lapCount })
: evenLapsProgress.bestStreakToday > 0
? t("evenLapsNewStreak")
: t("evenLapsStartHint"))}
${escapeHtml(t("evenLapsBestTodayLabel"))}${evenLapsProgress.bestStreakToday}
${evenLapsProgress.lastLapMs != null ? `
${escapeHtml(t("sessionLaps"))}${formatLap(evenLapsProgress.lastLapMs)}
` : ""}
` : `
${escapeHtml(evenLapsConfig ? t("evenLapsNotStarted") : t("evenLapsHint"))}
`}
${evenLapsSuggestedTargetMs && !evenLapsConfig ? `
${escapeHtml(t("evenLapsSuggestionHint", { lap: formatLap(evenLapsSuggestedTargetMs) }))}` : ""}
${escapeHtml(t("stepTrainingEyebrow"))}
${escapeHtml(t("stepTrainingTitle"))}
${stepTrainingConfig && stepTrainingProgress?.active ? `
${stepTrainingProgress.complete
? `
${escapeHtml(t("stepTrainingComplete"))}
`
: stepTrainingProgress.currentStep
? `
${escapeHtml(t("stepTrainingCurrent", { step: stepTrainingProgress.currentStepIndex + 1, total: stepTrainingProgress.totalSteps, effort: t(`effort${stepTrainingProgress.currentStep.effort.charAt(0).toUpperCase()}${stepTrainingProgress.currentStep.effort.slice(1)}`) }))}
${escapeHtml(t("stepTrainingRemaining", { laps: stepTrainingProgress.currentStep.lapsRemaining }))}
`
: ""}
${stepTrainingProgress.steps.map((step) => `
${escapeHtml(t(`effort${step.effort.charAt(0).toUpperCase()}${step.effort.slice(1)}`))} · ${step.lapsCompleted}/${step.lapCount}
`).join("")}
${stepTrainingProgress.controlledComparison ? `
${escapeHtml(t("stepTrainingCompare", {
first: formatLap(stepTrainingProgress.controlledComparison.firstAvgMs),
last: formatLap(stepTrainingProgress.controlledComparison.lastAvgMs),
diff: `${stepTrainingProgress.controlledComparison.diffMs >= 0 ? "+" : ""}${(stepTrainingProgress.controlledComparison.diffMs / 1000).toFixed(2)}s`,
}))}
` : ""}
` : `
${escapeHtml(stepTrainingConfig ? t("stepTrainingNotStarted") : t("stepTrainingHint"))}
`}
${escapeHtml(t("performance"))}
+
${escapeHtml(t("paceBlocks"))}
${escapeHtml(t("paceBlocksHint"))}
${paceBucketMarkup}
${escapeHtml(t("stintDetails"))}
| ${escapeHtml(t("stintNumber"))} | ${escapeHtml(t("date"))} | ${escapeHtml(t("laps"))} | ${escapeHtml(t("best"))} | ${escapeHtml(t("average"))} | ${escapeHtml(t("duration"))} |
${stintRows}
${visibility.goals && goals.length ? `
${escapeHtml(t("goals"))}
${goalMarkup}
` : ""}
${escapeHtml(t("history"))}
+
| ${escapeHtml(t("date"))} | ${escapeHtml(t("dayLaps"))} | ${escapeHtml(t("best"))} | ${escapeHtml(t("average"))} |
${historyRows}
${escapeHtml(t("exerciseHistoryTitle"))}
+
${escapeHtml(t("exerciseHistoryHint"))}
${exerciseSessionHistory.length ? `
${exerciseSessionHistory.map((entry) => {
const meta = exerciseKindMeta(entry.kind);
const date = new Date(entry.completedAt).toLocaleString(language, { dateStyle: "short", timeStyle: "short" });
const detail = entry.kind === "evenLaps"
? t("exerciseHistoryEvenLaps", { streak: entry.summary?.streak ?? "-", lap: formatLap(entry.summary?.targetMs) })
: entry.kind === "stepTraining"
? t("exerciseHistoryStepTraining", { steps: entry.summary?.totalSteps ?? "-", laps: entry.summary?.totalLaps ?? "-" })
: t("exerciseHistoryTimer", { laps: entry.summary?.laps ?? "-", lap: formatLap(entry.summary?.averageLapMs) });
return `
-
${meta.emoji}
${escapeHtml(t(meta.titleKey))}
${escapeHtml(date)} · ${escapeHtml(detail)}
`;
}).join("")}
` : `
${escapeHtml(t("exerciseHistoryEmpty"))}
`}
`;
const markerForm = document.getElementById("publicTrainingMarkerForm");
const draft = markerDrafts.get(selectedClassId);
if (markerForm && draft) {
markerForm.elements.namedItem("type").value = draft.type;
markerForm.elements.namedItem("note").value = draft.note;
}
document.getElementById("publicTrainingMarkerForm")?.addEventListener("submit", async (event) => {
event.preventDefault();
const form = event.currentTarget;
const status = document.getElementById("publicTrainingMarkerStatus");
const button = form.querySelector("button");
if (button) button.disabled = true;
try {
const values = new FormData(form);
const response = await fetch("/public-training/api/" + encodeURIComponent(shareToken) + "/markers", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ classId: selectedClassId, type: values.get("type"), note: values.get("note") }) });
if (!response.ok) throw new Error("HTTP " + response.status);
if (status) status.textContent = t("markerSaved");
form.reset();
await loadProfile();
} catch {
if (status) status.textContent = t("markerError");
} finally {
if (button) button.disabled = false;
}
});
document.getElementById("profileLayout")?.addEventListener("change", (event) => {
selectedLayout = String(event.currentTarget.value || "current");
const nextUrl = new URL(window.location.href);
if (selectedLayout !== "current") nextUrl.searchParams.set("layout", selectedLayout);
else nextUrl.searchParams.delete("layout");
window.history.replaceState({}, "", nextUrl);
loadProfile();
});
document.getElementById("profileSource")?.addEventListener("change", (event) => {
selectedSource = String(event.currentTarget.value || "practice");
const nextUrl = new URL(window.location.href);
if (selectedSource !== "practice") nextUrl.searchParams.set("source", selectedSource);
else nextUrl.searchParams.delete("source");
window.history.replaceState({}, "", nextUrl);
loadProfile();
});
document.getElementById("profileClass")?.addEventListener("change", (event) => {
selectedClassId = String(event.currentTarget.value || "");
const nextUrl = new URL(window.location.href);
if (selectedClassId) nextUrl.searchParams.set("class", selectedClassId);
else nextUrl.searchParams.delete("class");
window.history.replaceState({}, "", nextUrl);
lastTimerPhase = "";
renderProfile(profileData);
});
bindTimerControls();
updateTimerDisplay();
bindExerciseControls();
}
function renderStat(label, value) {
return `${escapeHtml(label)}${escapeHtml(value)}`;
}
function readTimerState() {
try {
const parsed = JSON.parse(localStorage.getItem(getTimerStorageKey()) || "null");
return parsed && typeof parsed === "object" ? parsed : null;
} catch {
return null;
}
}
function normalizeTimerConfig(value) {
const clampMinutes = (minutes) => Math.max(0, Math.min(MAX_TIMER_BLOCK_MINUTES, Math.round(Number(minutes) || 0)));
const config = {
pushMinutes: clampMinutes(value?.pushMinutes),
controlMinutes: clampMinutes(value?.controlMinutes),
};
return config.pushMinutes + config.controlMinutes > 0 ? config : { ...DEFAULT_TIMER_CONFIG };
}
function readTimerConfig() {
try {
return normalizeTimerConfig(JSON.parse(localStorage.getItem(getTimerConfigStorageKey()) || "null") || DEFAULT_TIMER_CONFIG);
} catch {
return { ...DEFAULT_TIMER_CONFIG };
}
}
function writeTimerConfig(value) {
const config = normalizeTimerConfig(value);
localStorage.setItem(getTimerConfigStorageKey(), JSON.stringify(config));
return config;
}
function getTimerConfig(state = null) {
if (state && (state.pushMinutes != null || state.controlMinutes != null)) return normalizeTimerConfig(state);
return readTimerConfig();
}
function getTimerDurationMs(config) {
return (Number(config.pushMinutes || 0) + Number(config.controlMinutes || 0)) * 60 * 1000;
}
function writeTimerState(value) {
if (value) localStorage.setItem(getTimerStorageKey(), JSON.stringify(value));
else localStorage.removeItem(getTimerStorageKey());
}
function getTimerStorageKey() {
return `rc-training-timer:${shareToken}:${selectedClassId || "default"}`;
}
function getTimerConfigStorageKey() {
return `rc-training-timer-config:${shareToken}:${selectedClassId || "default"}`;
}
// Remembers which timer session (identified by its startedAt) the driver has already
// dismissed the practice summary for, so it doesn't reappear on every later reload of the
// same finished session, but naturally shows again once a new session starts and finishes.
function getPracticeSummaryStorageKey() {
return `rc-training-practice-summary-dismissed:${shareToken}:${selectedClassId || "default"}`;
}
function readPracticeSummaryDismissedFor() {
try {
return localStorage.getItem(getPracticeSummaryStorageKey()) || "";
} catch {
return "";
}
}
function writePracticeSummaryDismissedFor(startedAtValue) {
try {
if (startedAtValue) localStorage.setItem(getPracticeSummaryStorageKey(), String(startedAtValue));
else localStorage.removeItem(getPracticeSummaryStorageKey());
} catch {}
}
// Remembers which run (by startedAt) of each of the three exercise kinds has already had a
// completion request sent for it, so a background re-render (this function runs on every
// renderProfile(), not just once) doesn't keep re-POSTing while the completed state persists.
function getExerciseRecordedStorageKey(kind) {
return `rc-training-${kind}-recorded:${shareToken}:${selectedClassId || "default"}`;
}
function readExerciseRecordedFor(kind) {
try {
return localStorage.getItem(getExerciseRecordedStorageKey(kind)) || "";
} catch {
return "";
}
}
function writeExerciseRecordedFor(kind, startedAtValue) {
try {
localStorage.setItem(getExerciseRecordedStorageKey(kind), String(startedAtValue));
} catch {}
}
// The driver's browser only ever *asks* the server to record a completion - the server
// independently recomputes the outcome from real ledger laps and refuses if it disagrees (see
// recordPublicExerciseSession in server/public_training_profile.js). This just avoids sending
// that request more than once per run.
async function maybeRecordExerciseCompletion(kind, startedAt, extra = {}) {
if (!startedAt || !selectedClassId) return;
if (readExerciseRecordedFor(kind) === String(startedAt)) return;
writeExerciseRecordedFor(kind, startedAt);
try {
const response = await fetch(`/public-training/api/${encodeURIComponent(shareToken)}/exercise-sessions`, {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({ classId: selectedClassId, kind, startedAgoMs: Math.max(0, Date.now() - startedAt), ...extra }),
});
if (response.ok) await loadProfile();
} catch {
// best-effort - a missed credit for one session is not worth retry complexity here
}
}
// The two guided exercises track progress by laps completed since the driver tapped
// "start", not by elapsed time, so unlike the timer above there is no pause/duration to
// manage locally - just a start timestamp (or none) per class, mirrored to the server as
// "started ago" on each poll so it can compute the sanitized streak/step progress.
function getExerciseRunStorageKey(kind) {
return `rc-training-${kind}-run:${shareToken}:${selectedClassId || "default"}`;
}
function readExerciseRunState(kind) {
try {
const parsed = JSON.parse(localStorage.getItem(getExerciseRunStorageKey(kind)) || "null");
return parsed && typeof parsed === "object" && parsed.startedAt ? parsed : null;
} catch {
return null;
}
}
function writeExerciseRunState(kind, value) {
const key = getExerciseRunStorageKey(kind);
if (value) localStorage.setItem(key, JSON.stringify(value));
else localStorage.removeItem(key);
}
function getTimerElapsed(state, now = Date.now()) {
if (!state?.startedAt) return 0;
const endpoint = state.pausedAt || now;
return Math.max(0, endpoint - state.startedAt - Number(state.pausedTotalMs || 0));
}
function bindTimerControls() {
const saveTimerSetup = () => {
const current = readTimerState();
if (current?.startedAt && getTimerElapsed(current) < getTimerDurationMs(getTimerConfig(current))) return;
if (current?.startedAt) writeTimerState(null);
const config = writeTimerConfig({
pushMinutes: document.getElementById("profilePushMinutes")?.value,
controlMinutes: document.getElementById("profileControlMinutes")?.value,
});
const pushInput = document.getElementById("profilePushMinutes");
const controlInput = document.getElementById("profileControlMinutes");
if (pushInput) pushInput.value = String(config.pushMinutes);
if (controlInput) controlInput.value = String(config.controlMinutes);
updateTimerDisplay();
};
document.getElementById("profilePushMinutes")?.addEventListener("change", saveTimerSetup);
document.getElementById("profileControlMinutes")?.addEventListener("change", saveTimerSetup);
document.getElementById("profileTimerStart")?.addEventListener("click", () => {
const current = readTimerState();
const currentDurationMs = getTimerDurationMs(getTimerConfig(current));
if (current?.pausedAt) {
current.pausedTotalMs = Number(current.pausedTotalMs || 0) + Date.now() - current.pausedAt;
current.pausedAt = 0;
writeTimerState(current);
} else if (!current || getTimerElapsed(current) >= currentDurationMs) {
const config = readTimerConfig();
writeTimerState({ startedAt: Date.now(), pausedAt: 0, pausedTotalMs: 0, ...config });
lastTimerPhase = config.pushMinutes > 0 ? "push" : "control";
void loadProfile();
}
startTimerLoop();
updateTimerDisplay();
});
document.getElementById("profileTimerPause")?.addEventListener("click", () => {
const current = readTimerState();
if (current?.startedAt && !current.pausedAt && getTimerElapsed(current) < getTimerDurationMs(getTimerConfig(current))) {
current.pausedAt = Date.now();
writeTimerState(current);
}
updateTimerDisplay();
});
document.getElementById("profileTimerReset")?.addEventListener("click", () => {
writeTimerState(null);
lastTimerPhase = "";
updateTimerDisplay();
void loadProfile();
});
document.getElementById("profileSummaryClose")?.addEventListener("click", () => {
const current = readTimerState();
writePracticeSummaryDismissedFor(current?.startedAt || "");
renderProfile(profileData);
});
startTimerLoop();
}
function bindExerciseControls() {
document.getElementById("profileEvenLapsSave")?.addEventListener("click", async () => {
const targetMs = Math.round(Number(document.getElementById("profileEvenLapsTarget")?.value || 0) * 1000);
const toleranceMs = Math.round(Number(document.getElementById("profileEvenLapsTolerance")?.value || 0) * 1000);
const lapCount = Math.max(1, Math.round(Number(document.getElementById("profileEvenLapsLapCount")?.value || 0) || 5));
if (!(targetMs > 0) || !(toleranceMs >= 0)) return;
const button = document.getElementById("profileEvenLapsSave");
if (button) button.disabled = true;
try {
await fetch(`/public-training/api/${encodeURIComponent(shareToken)}/even-laps`, { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ classId: selectedClassId, targetMs, toleranceMs, lapCount }) });
await loadProfile();
} finally {
if (button) button.disabled = false;
}
});
document.getElementById("profileEvenLapsStart")?.addEventListener("click", () => {
writeExerciseRunState("evenlaps", { startedAt: Date.now() });
void loadProfile();
});
document.getElementById("profileEvenLapsStop")?.addEventListener("click", () => {
writeExerciseRunState("evenlaps", null);
void loadProfile();
});
document.getElementById("profileStepTrainingSave")?.addEventListener("click", async () => {
const steps = [0, 1, 2, 3, 4]
.map((index) => ({
effort: String(document.getElementById(`profileStepEffort${index}`)?.value || "calm"),
lapCount: Math.max(0, Math.round(Number(document.getElementById(`profileStepLaps${index}`)?.value || 0) || 0)),
}))
.filter((step) => step.lapCount > 0);
if (!steps.length) return;
const button = document.getElementById("profileStepTrainingSave");
if (button) button.disabled = true;
try {
await fetch(`/public-training/api/${encodeURIComponent(shareToken)}/step-training`, { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ classId: selectedClassId, steps }) });
await loadProfile();
} finally {
if (button) button.disabled = false;
}
});
document.getElementById("profileStepTrainingStart")?.addEventListener("click", () => {
writeExerciseRunState("steptraining", { startedAt: Date.now() });
void loadProfile();
});
document.getElementById("profileStepTrainingStop")?.addEventListener("click", () => {
writeExerciseRunState("steptraining", null);
void loadProfile();
});
}
function startTimerLoop() {
if (timerHandle) clearInterval(timerHandle);
timerHandle = setInterval(updateTimerDisplay, 250);
}
function updateTimerDisplay() {
const timer = document.getElementById("profileTimer");
const phase = document.getElementById("profileTimerPhase");
const startButton = document.getElementById("profileTimerStart");
const pauseButton = document.getElementById("profileTimerPause");
const timerSetup = document.getElementById("profileTimerSetup");
const timerSetupHint = document.getElementById("profileTimerSetupHint");
if (!timer || !phase || !startButton || !pauseButton) return;
const state = readTimerState();
const config = getTimerConfig(state);
const timerDurationMs = getTimerDurationMs(config);
const pushDurationMs = Number(config.pushMinutes || 0) * 60 * 1000;
const elapsed = getTimerElapsed(state);
const remaining = Math.max(0, timerDurationMs - elapsed);
const phaseName = !state?.startedAt
? "ready"
: remaining <= 0
? "finished"
: config.pushMinutes > 0 && elapsed < pushDurationMs
? "push"
: "control";
timer.textContent = formatTimer(remaining || (phaseName === "ready" ? timerDurationMs : 0));
phase.textContent = t(phaseName);
startButton.textContent = state?.pausedAt ? t("resume") : !state?.startedAt || remaining <= 0 ? t("start") : t("running");
startButton.disabled = Boolean(state?.startedAt && !state.pausedAt && remaining > 0);
pauseButton.disabled = !state?.startedAt || Boolean(state.pausedAt) || remaining <= 0;
if (timerSetup) timerSetup.disabled = Boolean(state?.startedAt && remaining > 0);
if (timerSetupHint) timerSetupHint.textContent = t(state?.startedAt && remaining > 0 ? "timerLockedHint" : "timerSetupHint");
if (state?.startedAt && !state.pausedAt && phaseName !== lastTimerPhase) {
if (lastTimerPhase === "push" && phaseName === "control" && config.controlMinutes > 0) speak(t("switchCue"));
const justFinished = phaseName === "finished";
// Update the reentrancy guard before triggering a render: renderProfile() calls back
// into updateTimerDisplay() synchronously (see below), which would otherwise see the
// stale lastTimerPhase, take this branch again, and recurse without end.
lastTimerPhase = phaseName;
if (justFinished) {
speak(t("finishCue"));
void maybeRecordExerciseCompletion("timer", state.startedAt, { windowMs: timerDurationMs });
// Show the practice summary the moment the pass actually finishes, rather than
// waiting for the next background poll (up to 10s away) to pick it up.
if (profileData) renderProfile(profileData);
}
}
}
function speak(text) {
if (!("speechSynthesis" in window)) return;
window.speechSynthesis.cancel();
const utterance = new SpeechSynthesisUtterance(text);
utterance.lang = language === "sv" ? "sv-SE" : "en-GB";
window.speechSynthesis.speak(utterance);
}
const profileConnection = { lastSuccessAt: null, failed: false, loading: false };
function getProfileConnectionState(now = Date.now()) {
if (profileConnection.failed) return "failed";
if (profileConnection.lastSuccessAt !== null && now - profileConnection.lastSuccessAt >= 30000) return "stale";
return profileConnection.lastSuccessAt === null ? "loading" : "current";
}
function updateProfileConnectionStatus() {
const status = document.getElementById("publicTrainingConnection");
const label = document.getElementById("publicTrainingConnectionText");
const retry = document.getElementById("publicTrainingRetry");
if (!status || !label || !retry) return;
const state = getProfileConnectionState();
status.dataset.state = state;
const last = profileConnection.lastSuccessAt;
const text = t(`connection_${state}`) + (last === null ? "" : " " + t("connection_last", { time: new Date(last).toLocaleTimeString(language) }));
if (label.textContent !== text) label.textContent = text;
retry.textContent = t(profileConnection.loading ? "connection_retrying" : "connection_retry");
retry.hidden = state === "current" || (state === "loading" && !profileConnection.failed);
retry.disabled = profileConnection.loading;
}
// Only shown once the club has set up track layouts. Pace/best/consistency follow the
// choice; lifetime totals always cover every lap.
function renderLayoutSelect(trackLayouts) {
const options = Array.isArray(trackLayouts?.options) ? trackLayouts.options : [];
if (!options.length) return "";
const selected = trackLayouts.selected || "current";
const option = (value, label) => ``;
return ``;
}
// Practice by default; race laps (qualifying, heats, finals) only on request.
function renderSourceSelect(source) {
const selected = source || "practice";
const option = (value, label) => ``;
return ``;
}
async function loadProfile(background = false) {
if (profileConnection.loading || (background && profileIsBeingEdited())) return;
profileConnection.loading = true;
updateProfileConnectionStatus();
const controller = new AbortController();
const timeout = setTimeout(() => controller.abort(), 15000);
try {
const timerState = readTimerState();
const apiUrl = new URL(`/public-training/api/${encodeURIComponent(shareToken)}`, window.location.origin);
if (timerState?.startedAt) {
const now = Date.now();
const startedAgoMs = Math.max(0, now - timerState.startedAt);
const currentPauseMs = timerState.pausedAt ? Math.max(0, now - timerState.pausedAt) : 0;
const maximumWindowMs = getTimerDurationMs(getTimerConfig(timerState)) + Number(timerState.pausedTotalMs || 0) + currentPauseMs;
apiUrl.searchParams.set("startedAgoMs", String(startedAgoMs));
apiUrl.searchParams.set("windowMs", String(Math.min(startedAgoMs, maximumWindowMs)));
}
const evenLapsRun = readExerciseRunState("evenlaps");
if (evenLapsRun) apiUrl.searchParams.set("evenLapsStartedAgoMs", String(Math.max(0, Date.now() - evenLapsRun.startedAt)));
const stepTrainingRun = readExerciseRunState("steptraining");
if (stepTrainingRun) apiUrl.searchParams.set("stepTrainingStartedAgoMs", String(Math.max(0, Date.now() - stepTrainingRun.startedAt)));
if (selectedLayout !== "current") apiUrl.searchParams.set("layout", selectedLayout);
if (selectedSource !== "practice") apiUrl.searchParams.set("source", selectedSource);
const response = await fetch(apiUrl, { cache: "no-store", signal: controller.signal });
if (!response.ok) throw new Error(`HTTP ${response.status}`);
const data = await response.json();
if (background && profileIsBeingEdited()) return;
renderProfile(data);
profileConnection.lastSuccessAt = Date.now();
profileConnection.failed = false;
} catch {
profileConnection.failed = true;
if (background && profileData) return;
root.innerHTML = `RC
${escapeHtml(t("loadError"))}
`;
} finally {
clearTimeout(timeout);
profileConnection.loading = false;
updateProfileConnectionStatus();
}
}
loadProfile();
document.getElementById("publicTrainingRetry")?.addEventListener("click", () => loadProfile(true));
setInterval(updateProfileConnectionStatus, 1000);
setInterval(() => {
if (!document.hidden) loadProfile(true);
}, 10000);